// Die with an error message. void error_exit(char *msg, ...) { va_list va; va_start(va, msg); verror_msg(msg, 0, va); va_end(va); xexit(); }
static void fail (const char *message, ...) { va_list args; va_start (args, message); fprintf (stderr, _("%s: Error: "), program_name); vfprintf (stderr, message, args); va_end (args); xexit (1); }
RETSIGTYPE sigpipe_handler(int x) /* handle broken pipes ... */ { fprintf(stderr, "Broken pipe : fcron may have closed the connection\nThe connection " "has been idle for more than %ds, or fcron may not be running anymore.\n", MAX_IDLE_TIME); fprintf(stderr, "Exiting ...\n"); xexit(EXIT_ERR); }
// Exit with an error message after showing help text. void help_exit(char *msg, ...) { va_list va; if (CFG_TOYBOX_HELP) show_help(stderr); va_start(va, msg); verror_msg(msg, 0, va); va_end(va); xexit(); }
bool xatob(const char * str) { StrNum conv; bool b = conv.tob(str); if (!conv.ok()) { if (conv.getStatus() == StrNum::BAD_STRING) { fprintf(stderr, "xatob(\"%s\") : bad string-to-boolean conversion.\n", str); } xexit(1); } return b; }
int xopen(char *str, int flags) { int fd; fd = open(str, flags); if (fd == -1) { my_putstr_err("Error: file "); my_putstr_err(str); xexit(" not accessible\n"); } return (fd); }
void as_assert (const char *file, int line, const char *fn) { as_show_where (); fprintf (stderr, _("Internal error!\n")); if (fn) fprintf (stderr, _("Assertion failure in %s at %s:%d.\n"), fn, file, line); else fprintf (stderr, _("Assertion failure at %s:%d.\n"), file, line); fprintf (stderr, _("Please report this bug.\n")); xexit (EXIT_FAILURE); }
void as_abort (const char *file, int line, const char *fn) { as_show_where (); if (fn) fprintf (stderr, _("Internal error, aborting at %s:%d in %s\n"), file, line, fn); else fprintf (stderr, _("Internal error, aborting at %s:%d\n"), file, line); fprintf (stderr, _("Please report this bug.\n")); xexit (EXIT_FAILURE); }
static void process_pcap( uint8_t *args, const struct pcap_pkthdr *hdr, const uint8_t *p ) { if (direct) xcache_process_packet((uint8_t *)p); else if (xproc((void *)p, hdr->len)) { xexit(); exit(0); } }
void exitstat(void) { Char *s; /* * Note that if STATUS is corrupted (i.e. getn bombs) then error will exit * directly because we poke child here. Otherwise we might continue * unwarrantedly (sic). */ child = 1; s = value(STRstatus); xexit(s ? getn(s) : 0); }
int main(int argc, char *argv[]) { pcap_t *p; struct bpf_program fp; if (argc > 1 && strstr(argv[1], ".scap")) { FILE *fp = fopen(argv[1], "rb"); int len; static char packet[1*1024*1024]; xcache_init(); printf("replay %s\n", argv[1]); while (fread(&len, 1, sizeof(len), fp) == sizeof(len)) { fread(packet, 1, len, fp); xcache_process_packet(packet); } return 0; } if (argc > 1 && strstr(argv[1], ".pcap")) { xcache_init(); printf("replay %s\n", argv[1]); p = pcap_open_offline(argv[1], NULL); direct = 1; pcap_loop(p, -1, process_pcap, NULL); return 0; } if (getenv("cap")) cap = atoi(getenv("cap")); if (cap == 0) { printf("capture=pcap\n"); xinit(); p = pcap_open_live("eth1", BUFSIZ, 1, 1000, NULL); pcap_compile(p, &fp, "port 80", 0, 0); pcap_setfilter(p, &fp); pcap_loop(p, -1, process_pcap, NULL); return 1; } if (cap == 1) { printf("capture=raw\n"); xinit(); raw_loop(); xexit(); } printf("unknown mode\n"); return 1; }
int xatoi(const char *str) { StrNum conv; int n = conv.toi(str); if (!conv.ok()) { if (conv.getStatus() == StrNum::BAD_STRING) { fprintf(stderr, "xatoi(\"%s\") : bad string-to-integer conversion.\n", str); } else if (conv.getStatus() == StrNum::OUT_OF_RANGE) { fprintf(stderr, "xatoi(\"%s\") : Value out of range.\n",str); } xexit(1); } return n; }
unsigned long xatoul(const char *str) { StrNum conv; unsigned long n = conv.toul(str); if (!conv.ok()) { if (conv.getStatus() == StrNum::BAD_STRING) { fprintf(stderr, "xatoul(\"%s\") : bad string-to-integer conversion.\n", str); } else if (conv.getStatus() == StrNum::OUT_OF_RANGE) { fprintf(stderr, "xatoul(\"%s\")",str); perror(" "); } xexit(1); } return n; }
double xatof(const char *str) { StrNum conv; double x = conv.tof(str); if (!conv.ok()) { if (conv.getStatus() == StrNum::BAD_STRING) { fprintf(stderr, "xatof(\"%s\") : Bad string-to-double conversion.\n", str); } else if (conv.getStatus() == StrNum::OUT_OF_RANGE) { fprintf(stderr, "xatof(\"%s\")",str); perror(" "); } xexit(1); } return x; }
__dead void exitstat(void) { Char *s; #ifdef PROF monitor(0); #endif /* * Note that if STATUS is corrupted (i.e. getn bombs) then error will exit * directly because we poke child here. Otherwise we might continue * unwarrantedly (sic). */ child = 1; s = value(STRstatus); xexit(s ? getn(s) : 0); /* NOTREACHED */ }
void usage(void) { xprintf("usage: go tool dist [command]\n" "Commands are:\n" "\n" "banner print installation banner\n" "bootstrap rebuild everything\n" "clean deletes all built files\n" "env [-p] print environment (-p: include $PATH)\n" "install [dir] install individual directory\n" "version print Go version\n" "\n" "All commands take -v flags to emit extra information.\n" ); xexit(2); }
void as_fatal (const char *format, ...) { va_list args; as_show_where (); va_start (args, format); fprintf (stderr, _("Fatal error: ")); vfprintf (stderr, format, args); (void) putc ('\n', stderr); va_end (args); /* Delete the output file, if it exists. This will prevent make from thinking that a file was created and hence does not need rebuilding. */ if (out_file_name != NULL) unlink_if_ordinary (out_file_name); xexit (EXIT_FAILURE); }
static void ATTRIBUTE_NORETURN show_usage(FILE *file, int status) { fprintf(file, _("Usage: %s [option(s)] in-file\n"), program_name); fprintf(file, _(" Print a human readable interpretation of a SYSROFF object file\n")); fprintf(file, _(" The options are:\n\ -h --help Display this information\n\ -v --version Display the program's version\n\ \n")); if (status == 0) { fprintf(file, _("Report bugs to %s\n"), REPORT_BUGS_TO); } xexit(status); }
int add_client(t_env *e, int s) { int cs; struct sockaddr_in client_sin; socklen_t client_sin_len; char str[12]; client_sin_len = sizeof(client_sin); if ((cs = accept(s, (struct sockaddr *)&client_sin, &client_sin_len)) == -1) xexit(s, strerror(errno)); e->fd_type[cs] = FD_CLIENT; e->fct_read[cs] = client_read; e->fct_write[cs] = sendmess; sprintf(str, "Player %d", cs); e->name[cs] = strdup(str); dprintf(cs, "BIENVENUE\n"); return (cs); }
// Like exec() but runs an internal toybox command instead of another file. // Only returns if it can't run command internally, otherwise exit() when done. void toy_exec(char *argv[]) { struct toy_list *which; // Return if we can't find it (which includes no multiplexer case), if (!(which = toy_find(*argv))) return; // Return if stack depth getting noticeable (proxy for leaked heap, etc). if (toys.stacktop && labs((char *)toys.stacktop-(char *)&which)>6000) return; // Return if we need to re-exec to acquire root via suid bit. if (toys.which && (which->flags&TOYFLAG_ROOTONLY) && toys.wasroot) return; // Run command toy_init(which, argv); if (toys.which) toys.which->toy_main(); xexit(); }
static void usage() { eprintf("Usage: %s [OPTIONS] DISK\n" "where OPTIONS are:\n" "\t-V display version information\n" "\t-f FILE File to copy. The FILE may be a gzipped file.\n" "\t If not specified, it defaults to minifs.gz.\n" "\t-h display this help and exit\n" "\t-o FILE send output to FILE instead of stdout\n" "\t-w wait for key press before exiting\n\n" "DISK is the concatenation of BUS, TARGET and LUN.\n" "BUS is one of `i' (IDE), `a' (ACSI) or `s' (SCSI).\n" "TARGET and LUN are one decimal digit each. LUN must\n" "not be specified for IDE devices and is optional for\n" "ACSI/SCSI devices (if omitted, LUN defaults to 0).\n\n" "Examples: a0 refers to ACSI target 0 lun 0\n" " s21 refers to SCSI target 2 lun 1\n" , program_name); xexit(EXIT_SUCCESS); }
// Multiplexer command, first argument is command to run, rest are args to that. // If first argument starts with - output list of command install paths. void toybox_main(void) { static char *toy_paths[]={"usr/","bin/","sbin/",0}; int i, len = 0; // fast path: try to exec immediately. // (Leave toys.which null to disable suid return logic.) if (toys.argv[1]) toy_exec(toys.argv+1); // For early error reporting toys.which = toy_list; if (toys.argv[1]) { if (!strcmp("--version", toys.argv[1])) { xputs(TOYBOX_VERSION); xexit(); } if (toys.argv[1][0] != '-') { toys.exitval = 127; error_exit("Unknown command %s", toys.argv[1]); } } // Output list of command. for (i=1; i<ARRAY_LEN(toy_list); i++) { int fl = toy_list[i].flags; if (fl & TOYMASK_LOCATION) { if (toys.argv[1]) { int j; for (j=0; toy_paths[j]; j++) if (fl & (1<<j)) len += printf("%s", toy_paths[j]); } len += printf("%s",toy_list[i].name); if (++len > 65) len = 0; xputc(len ? ' ' : '\n'); } } xputc('\n'); }
void fixerror(void) { didfds = 0; /* Forget about 0,1,2 */ /* * Go away if -e or we are a child shell */ if (!exitset || exiterr || child) xexit(1); /* * Reset the state of the input. This buffered seek to end of file will * also clear the while/foreach stack. */ btoeof(); setcopy(STRstatus, STR1, VAR_READWRITE);/*FIXRESET*/ #ifdef BSDJOBS if (tpgrp > 0) (void) tcsetpgrp(FSHTTY, tpgrp); #endif }
/* * in the event of a HUP we want to save the history */ static void phup(int sig) { /* XXX sigh, everything after this is a signal race */ rechist(); /* * We kill the last foreground process group. It then becomes * responsible to propagate the SIGHUP to its progeny. */ { struct process *pp, *np; for (pp = proclist.p_next; pp; pp = pp->p_next) { np = pp; /* * Find if this job is in the foreground. It could be that * the process leader has exited and the foreground flag * is cleared for it. */ do /* * If a process is in the foreground; we try to kill * it's process group. If we succeed, then the * whole job is gone. Otherwise we keep going... * But avoid sending HUP to the shell again. */ if ((np->p_flags & PFOREGND) != 0 && np->p_jobid != shpgrp && kill(-np->p_jobid, SIGHUP) != -1) { /* In case the job was suspended... */ (void) kill(-np->p_jobid, SIGCONT); break; } while ((np = np->p_friends) != pp); } } xexit(sig); }
void xmalloc_failed (size_t size) { #ifdef HAVE_SBRK size_t allocated; if (first_break != NULL) allocated = (char *) sbrk (0) - first_break; else allocated = (char *) sbrk (0) - (char *) &environ; fprintf (stderr, "\n%s%sout of memory allocating %lu bytes after a total of %lu bytes\n", name, *name ? ": " : "", (unsigned long) size, (unsigned long) allocated); #else /* HAVE_SBRK */ fprintf (stderr, "\n%s%sout of memory allocating %lu bytes\n", name, *name ? ": " : "", (unsigned long) size); #endif /* HAVE_SBRK */ xexit (1); }
// Setup toybox global state for this command. static void toy_singleinit(struct toy_list *which, char *argv[]) { toys.which = which; toys.argv = argv; if (CFG_TOYBOX_I18N) setlocale(LC_ALL, "C"+!!(which->flags & TOYFLAG_LOCALE)); if (CFG_TOYBOX_HELP_DASHDASH && argv[1] && !strcmp(argv[1], "--help")) { if (CFG_TOYBOX && toys.which == toy_list && toys.argv[2]) if (!(toys.which = toy_find(toys.argv[2]))) return; show_help(stdout); xexit(); } if (NEED_OPTIONS && which->options) get_optflags(); else { toys.optargs = argv+1; for (toys.optc = 0; toys.optargs[toys.optc]; toys.optc++); } toys.old_umask = umask(0); if (!(which->flags & TOYFLAG_UMASK)) umask(toys.old_umask); toys.signalfd--; toys.toycount = ARRAY_LEN(toy_list); }
int main (int argc, char **argv) { char *emulation; long start_time = get_run_time (); #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES) setlocale (LC_MESSAGES, ""); #endif #if defined (HAVE_SETLOCALE) setlocale (LC_CTYPE, ""); #endif bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); program_name = argv[0]; xmalloc_set_program_name (program_name); START_PROGRESS (program_name, 0); expandargv (&argc, &argv); bfd_init (); bfd_set_error_program_name (program_name); xatexit (ld_cleanup); /* Set up the sysroot directory. */ ld_sysroot = get_sysroot (argc, argv); if (*ld_sysroot) { if (*TARGET_SYSTEM_ROOT == 0) { einfo ("%P%F: this linker was not configured to use sysroots\n"); ld_sysroot = ""; } else ld_canon_sysroot = lrealpath (ld_sysroot); } if (ld_canon_sysroot) ld_canon_sysroot_len = strlen (ld_canon_sysroot); else ld_canon_sysroot_len = -1; /* Set the default BFD target based on the configured target. Doing this permits the linker to be configured for a particular target, and linked against a shared BFD library which was configured for a different target. The macro TARGET is defined by Makefile. */ if (! bfd_set_default_target (TARGET)) { einfo (_("%X%P: can't set BFD default target to `%s': %E\n"), TARGET); xexit (1); } #if YYDEBUG { extern int yydebug; yydebug = 1; } #endif config.build_constructors = TRUE; config.rpath_separator = ':'; config.split_by_reloc = (unsigned) -1; config.split_by_file = (bfd_size_type) -1; config.make_executable = TRUE; config.magic_demand_paged = TRUE; config.text_read_only = TRUE; command_line.warn_mismatch = TRUE; command_line.warn_search_mismatch = TRUE; command_line.check_section_addresses = -1; command_line.disable_target_specific_optimizations = -1; /* We initialize DEMANGLING based on the environment variable COLLECT_NO_DEMANGLE. The gcc collect2 program will demangle the output of the linker, unless COLLECT_NO_DEMANGLE is set in the environment. Acting the same way here lets us provide the same interface by default. */ demangling = getenv ("COLLECT_NO_DEMANGLE") == NULL; link_info.allow_undefined_version = TRUE; link_info.keep_memory = TRUE; link_info.combreloc = TRUE; link_info.strip_discarded = TRUE; link_info.emit_hash = TRUE; link_info.callbacks = &link_callbacks; link_info.input_bfds_tail = &link_info.input_bfds; /* SVR4 linkers seem to set DT_INIT and DT_FINI based on magic _init and _fini symbols. We are compatible. */ link_info.init_function = "_init"; link_info.fini_function = "_fini"; link_info.relax_pass = 1; link_info.pei386_auto_import = -1; link_info.spare_dynamic_tags = 5; link_info.path_separator = ':'; ldfile_add_arch (""); emulation = get_emulation (argc, argv); ldemul_choose_mode (emulation); default_target = ldemul_choose_target (argc, argv); config.maxpagesize = bfd_emul_get_maxpagesize (default_target); config.commonpagesize = bfd_emul_get_commonpagesize (default_target); lang_init (); ldemul_before_parse (); lang_has_input_file = FALSE; parse_args (argc, argv); if (config.hash_table_size != 0) bfd_hash_set_default_size (config.hash_table_size); ldemul_set_symbols (); if (link_info.relocatable) { if (command_line.check_section_addresses < 0) command_line.check_section_addresses = 0; if (link_info.shared) einfo (_("%P%F: -r and -shared may not be used together\n")); } /* We may have -Bsymbolic, -Bsymbolic-functions, --dynamic-list-data, --dynamic-list-cpp-new, --dynamic-list-cpp-typeinfo and --dynamic-list FILE. -Bsymbolic and -Bsymbolic-functions are for shared libraries. -Bsymbolic overrides all others and vice versa. */ switch (command_line.symbolic) { case symbolic_unset: break; case symbolic: /* -Bsymbolic is for shared library only. */ if (link_info.shared) { link_info.symbolic = TRUE; /* Should we free the unused memory? */ link_info.dynamic_list = NULL; command_line.dynamic_list = dynamic_list_unset; } break; case symbolic_functions: /* -Bsymbolic-functions is for shared library only. */ if (link_info.shared) command_line.dynamic_list = dynamic_list_data; break; } switch (command_line.dynamic_list) { case dynamic_list_unset: break; case dynamic_list_data: link_info.dynamic_data = TRUE; case dynamic_list: link_info.dynamic = TRUE; break; } if (! link_info.shared) { if (command_line.filter_shlib) einfo (_("%P%F: -F may not be used without -shared\n")); if (command_line.auxiliary_filters) einfo (_("%P%F: -f may not be used without -shared\n")); } if (! link_info.shared || link_info.pie) link_info.executable = TRUE; /* Treat ld -r -s as ld -r -S -x (i.e., strip all local symbols). I don't see how else this can be handled, since in this case we must preserve all externally visible symbols. */ if (link_info.relocatable && link_info.strip == strip_all) { link_info.strip = strip_debugger; if (link_info.discard == discard_sec_merge) link_info.discard = discard_all; } /* If we have not already opened and parsed a linker script, try the default script from command line first. */ if (saved_script_handle == NULL && command_line.default_script != NULL) { ldfile_open_command_file (command_line.default_script); parser_input = input_script; yyparse (); } /* If we have not already opened and parsed a linker script read the emulation's appropriate default script. */ if (saved_script_handle == NULL) { int isfile; char *s = ldemul_get_script (&isfile); if (isfile) ldfile_open_default_command_file (s); else { lex_string = s; lex_redirect (s); } parser_input = input_script; yyparse (); lex_string = NULL; } if (trace_file_tries) { if (saved_script_handle) info_msg (_("using external linker script:")); else info_msg (_("using internal linker script:")); info_msg ("\n==================================================\n"); if (saved_script_handle) { static const int ld_bufsz = 8193; size_t n; char *buf = (char *) xmalloc (ld_bufsz); rewind (saved_script_handle); while ((n = fread (buf, 1, ld_bufsz - 1, saved_script_handle)) > 0) { buf[n] = 0; info_msg (buf); } rewind (saved_script_handle); free (buf); } else { int isfile; info_msg (ldemul_get_script (&isfile)); } info_msg ("\n==================================================\n"); } lang_final (); if (!lang_has_input_file) { if (version_printed) xexit (0); einfo (_("%P%F: no input files\n")); } if (trace_files) info_msg (_("%P: mode %s\n"), emulation); ldemul_after_parse (); if (config.map_filename) { if (strcmp (config.map_filename, "-") == 0) { config.map_file = stdout; } else { config.map_file = fopen (config.map_filename, FOPEN_WT); if (config.map_file == (FILE *) NULL) { bfd_set_error (bfd_error_system_call); einfo (_("%P%F: cannot open map file %s: %E\n"), config.map_filename); } } } lang_process (); /* Print error messages for any missing symbols, for any warning symbols, and possibly multiple definitions. */ if (link_info.relocatable) link_info.output_bfd->flags &= ~EXEC_P; else link_info.output_bfd->flags |= EXEC_P; ldwrite (); if (config.map_file != NULL) lang_map (); if (command_line.cref) output_cref (config.map_file != NULL ? config.map_file : stdout); if (nocrossref_list != NULL) check_nocrossrefs (); lang_finish (); /* Even if we're producing relocatable output, some non-fatal errors should be reported in the exit status. (What non-fatal errors, if any, do we want to ignore for relocatable output?) */ if (!config.make_executable && !force_make_executable) { if (trace_files) einfo (_("%P: link errors found, deleting executable `%s'\n"), output_filename); /* The file will be removed by remove_output. */ xexit (1); } else { if (! bfd_close (link_info.output_bfd)) einfo (_("%F%B: final close failed: %E\n"), link_info.output_bfd); /* If the --force-exe-suffix is enabled, and we're making an executable file and it doesn't end in .exe, copy it to one which does. */ if (! link_info.relocatable && command_line.force_exe_suffix) { int len = strlen (output_filename); if (len < 4 || (strcasecmp (output_filename + len - 4, ".exe") != 0 && strcasecmp (output_filename + len - 4, ".dll") != 0)) { FILE *src; FILE *dst; const int bsize = 4096; char *buf = (char *) xmalloc (bsize); int l; char *dst_name = (char *) xmalloc (len + 5); strcpy (dst_name, output_filename); strcat (dst_name, ".exe"); src = fopen (output_filename, FOPEN_RB); dst = fopen (dst_name, FOPEN_WB); if (!src) einfo (_("%X%P: unable to open for source of copy `%s'\n"), output_filename); if (!dst) einfo (_("%X%P: unable to open for destination of copy `%s'\n"), dst_name); while ((l = fread (buf, 1, bsize, src)) > 0) { int done = fwrite (buf, 1, l, dst); if (done != l) einfo (_("%P: Error writing file `%s'\n"), dst_name); } fclose (src); if (fclose (dst) == EOF) einfo (_("%P: Error closing file `%s'\n"), dst_name); free (dst_name); free (buf); } } } END_PROGRESS (program_name); if (config.stats) { #ifdef HAVE_SBRK char *lim = (char *) sbrk (0); #endif long run_time = get_run_time () - start_time; fflush (stdout); fprintf (stderr, _("%s: total time in link: %ld.%06ld\n"), program_name, run_time / 1000000, run_time % 1000000); #ifdef HAVE_SBRK fprintf (stderr, _("%s: data size %ld\n"), program_name, (long) (lim - (char *) &environ)); #endif fflush (stderr); } /* Prevent remove_output from doing anything, after a successful link. */ output_filename = NULL; xexit (0); return 0; }
/* * Print the error with the given id. * * Special ids: * ERR_SILENT: Print nothing. * ERR_OLD: Print the previously set error if one was there. * otherwise return. * ERR_NAME: If this bit is set, print the name of the function * in bname * * This routine always resets or exits. The flag haderr * is set so the routine who catches the unwind can propogate * it if they want. * * Note that any open files at the point of error will eventually * be closed in the routine process in sh.c which is the only * place error unwinds are ever caught. */ void stderror(int id, ...) { va_list va; Char **v; int flags; flags = id & ERR_FLAGS; id &= ~ERR_FLAGS; if ((flags & ERR_OLD) && seterr == NULL) abort(); if (id < 0 || id > (int)(sizeof(errorlist) / sizeof(errorlist[0]))) id = ERR_INVALID; (void)fflush(cshout); (void)fflush(csherr); haderr = 1; /* Now to diagnostic output */ timflg = 0; /* This isn't otherwise reset */ if (!(flags & ERR_SILENT)) { if (flags & ERR_NAME) (void)fprintf(csherr, "%s: ", bname); if ((flags & ERR_OLD)) /* Old error. */ (void)fprintf(csherr, "%s.\n", seterr); else { va_start(va, id); (void)vfprintf(csherr, errorlist[id], va); va_end(va); (void)fprintf(csherr, ".\n"); } } if (seterr) { xfree((ptr_t) seterr); seterr = NULL; } if ((v = pargv) != NULL) pargv = 0, blkfree(v); if ((v = gargv) != NULL) gargv = 0, blkfree(v); (void)fflush(cshout); (void)fflush(csherr); didfds = 0; /* Forget about 0,1,2 */ /* * Go away if -e or we are a child shell */ if (exiterr || child) xexit(1); /* * Reset the state of the input. This buffered seek to end of file will * also clear the while/foreach stack. */ btoeof(); set(STRstatus, Strsave(STR1)); if (tpgrp > 0) (void)tcsetpgrp(FSHTTY, tpgrp); reset(); /* Unwind */ }
/* ** parse_args() ** ** This function is called for each command-line option. */ static int gldelf32pic32mx_parse_args (int argc, char ** argv) { int longind; int optc; int prevoptind = optind; int prevopterr = opterr; int wanterror; static int lastoptind = -1; const char *smart_io_option_err = "--smart-io and --no-smart-io"; const char *option_err = " options can not be used together\n"; const char *data_init_option_err = "--data-init and --no-data-init"; if (lastoptind != optind) opterr = 0; wanterror = opterr; lastoptind = optind; optc = getopt_long_only (argc, argv, shortopts, longopts, & longind); opterr = prevopterr; switch (optc) { default: if (wanterror) xexit (1); optind = prevoptind; return 0; case 'D': pic32_debug = TRUE; break; case SMART_IO_OPTION: if (pic32_has_smart_io_option && (!pic32_smart_io)) einfo(_("%P%F: Error: %s%s"), smart_io_option_err, option_err); pic32_smart_io = TRUE; pic32_has_smart_io_option = TRUE; break; case NO_SMART_IO_OPTION: if (pic32_has_smart_io_option && (pic32_smart_io)) einfo(_("%P%F: Error: %s%s"), smart_io_option_err, option_err); pic32_smart_io = FALSE; pic32_has_smart_io_option = TRUE; break; case REPORT_MEM_OPTION: pic32_report_mem = TRUE; break; case DATA_INIT_OPTION: if (pic32_has_data_init_option && (!pic32_data_init)) einfo(_("%P%F: Error: %s%s"), data_init_option_err, option_err); pic32_data_init = TRUE; pic32_has_data_init_option = TRUE; break; case NO_DATA_INIT_OPTION: if (pic32_has_data_init_option && (pic32_data_init)) einfo(_("%P%F: Error: %s%s"), data_init_option_err, option_err); pic32_data_init = FALSE; pic32_has_data_init_option = TRUE; break; } return 1; } /* static int gldelf32pic32mx_parse_args ()*/
void vfinfo (FILE *fp, const char *fmt, va_list ap, bfd_boolean is_warning) { bfd_boolean fatal = FALSE; const char *scan; int arg_type; unsigned int arg_count = 0; unsigned int arg_no; union vfinfo_args { int i; long l; void *p; bfd_vma v; struct { bfd *abfd; asection *sec; bfd_vma off; } reladdr; enum { Bad, Int, Long, Ptr, Vma, RelAddr } type; } args[9]; for (arg_no = 0; arg_no < sizeof (args) / sizeof (args[0]); arg_no++) args[arg_no].type = Bad; arg_count = 0; scan = fmt; while (*scan != '\0') { while (*scan != '%' && *scan != '\0') scan++; if (*scan == '%') { scan++; arg_no = arg_count; if (*scan != '0' && ISDIGIT (*scan) && scan[1] == '$') { arg_no = *scan - '1'; scan += 2; } arg_type = Bad; switch (*scan++) { case '\0': --scan; break; case 'V': case 'v': case 'W': arg_type = Vma; break; case 's': arg_type = Ptr; break; case 'p': if (*scan == 'A' || *scan == 'B' || *scan == 'I' || *scan == 'R' || *scan == 'S' || *scan == 'T') scan++; arg_type = Ptr; break; case 'C': case 'D': case 'G': case 'H': arg_type = RelAddr; break; case 'd': case 'u': arg_type = Int; break; case 'l': if (*scan == 'd' || *scan == 'u') { ++scan; arg_type = Long; } break; default: break; } if (arg_type != Bad) { if (arg_no >= sizeof (args) / sizeof (args[0])) abort (); args[arg_no].type = arg_type; ++arg_count; } } } for (arg_no = 0; arg_no < arg_count; arg_no++) { switch (args[arg_no].type) { case Int: args[arg_no].i = va_arg (ap, int); break; case Long: args[arg_no].l = va_arg (ap, long); break; case Ptr: args[arg_no].p = va_arg (ap, void *); break; case Vma: args[arg_no].v = va_arg (ap, bfd_vma); break; case RelAddr: args[arg_no].reladdr.abfd = va_arg (ap, bfd *); args[arg_no].reladdr.sec = va_arg (ap, asection *); args[arg_no].reladdr.off = va_arg (ap, bfd_vma); break; default: abort (); } } arg_count = 0; while (*fmt != '\0') { const char *str = fmt; while (*fmt != '%' && *fmt != '\0') fmt++; if (fmt != str) if (fwrite (str, 1, fmt - str, fp)) { /* Ignore. */ } if (*fmt == '%') { fmt++; arg_no = arg_count; if (*fmt != '0' && ISDIGIT (*fmt) && fmt[1] == '$') { arg_no = *fmt - '1'; fmt += 2; } switch (*fmt++) { case '\0': --fmt; /* Fall through. */ case '%': /* literal % */ putc ('%', fp); break; case 'X': /* no object output, fail return */ config.make_executable = FALSE; break; case 'V': /* hex bfd_vma */ { bfd_vma value = args[arg_no].v; ++arg_count; fprintf_vma (fp, value); } break; case 'v': /* hex bfd_vma, no leading zeros */ { char buf[100]; char *p = buf; bfd_vma value = args[arg_no].v; ++arg_count; sprintf_vma (p, value); while (*p == '0') p++; if (!*p) p--; fputs (p, fp); } break; case 'W': /* hex bfd_vma with 0x with no leading zeroes taking up 8 spaces. */ { char buf[100]; bfd_vma value; char *p; int len; value = args[arg_no].v; ++arg_count; sprintf_vma (buf, value); for (p = buf; *p == '0'; ++p) ; if (*p == '\0') --p; len = strlen (p); while (len < 8) { putc (' ', fp); ++len; } fprintf (fp, "0x%s", p); } break; case 'F': /* Error is fatal. */ fatal = TRUE; break; case 'P': /* Print program name. */ fprintf (fp, "%s", program_name); break; case 'E': /* current bfd error or errno */ fprintf (fp, "%s", bfd_errmsg (bfd_get_error ())); break; case 'C': case 'D': case 'G': case 'H': /* Clever filename:linenumber with function name if possible. The arguments are a BFD, a section, and an offset. */ { static bfd *last_bfd; static char *last_file; static char *last_function; bfd *abfd; asection *section; bfd_vma offset; asymbol **asymbols = NULL; const char *filename; const char *functionname; unsigned int linenumber; bfd_boolean discard_last; bfd_boolean done; abfd = args[arg_no].reladdr.abfd; section = args[arg_no].reladdr.sec; offset = args[arg_no].reladdr.off; ++arg_count; if (abfd != NULL) { if (!bfd_generic_link_read_symbols (abfd)) einfo (_("%F%P: %pB: could not read symbols: %E\n"), abfd); asymbols = bfd_get_outsymbols (abfd); } /* The GNU Coding Standard requires that error messages be of the form: source-file-name:lineno: message We do not always have a line number available so if we cannot find them we print out the section name and offset instead. */ discard_last = TRUE; if (abfd != NULL && bfd_find_nearest_line (abfd, section, asymbols, offset, &filename, &functionname, &linenumber)) { if (functionname != NULL && (fmt[-1] == 'C' || fmt[-1] == 'H')) { /* Detect the case where we are printing out a message for the same function as the last call to vinfo ("%C"). In this situation do not print out the ABFD filename or the function name again. Note - we do still print out the source filename, as this will allow programs that parse the linker's output (eg emacs) to correctly locate multiple errors in the same source file. */ if (last_bfd == NULL || last_function == NULL || last_bfd != abfd || (last_file == NULL) != (filename == NULL) || (filename != NULL && filename_cmp (last_file, filename) != 0) || strcmp (last_function, functionname) != 0) { lfinfo (fp, _("%pB: in function `%pT':\n"), abfd, functionname); last_bfd = abfd; if (last_file != NULL) free (last_file); last_file = NULL; if (filename) last_file = xstrdup (filename); if (last_function != NULL) free (last_function); last_function = xstrdup (functionname); } discard_last = FALSE; } else lfinfo (fp, "%pB:", abfd); if (filename != NULL) fprintf (fp, "%s:", filename); done = fmt[-1] != 'H'; if (functionname != NULL && fmt[-1] == 'G') lfinfo (fp, "%pT", functionname); else if (filename != NULL && linenumber != 0) fprintf (fp, "%u%s", linenumber, done ? "" : ":"); else done = FALSE; } else { lfinfo (fp, "%pB:", abfd); done = FALSE; } if (!done) lfinfo (fp, "(%pA+0x%v)", section, offset); if (discard_last) { last_bfd = NULL; if (last_file != NULL) { free (last_file); last_file = NULL; } if (last_function != NULL) { free (last_function); last_function = NULL; } } } break; case 'p': if (*fmt == 'A') { /* section name from a section */ asection *sec; bfd *abfd; const char *group = NULL; struct coff_comdat_info *ci; fmt++; sec = (asection *) args[arg_no].p; ++arg_count; abfd = sec->owner; fprintf (fp, "%s", sec->name); if (abfd != NULL && bfd_get_flavour (abfd) == bfd_target_elf_flavour && elf_next_in_group (sec) != NULL && (sec->flags & SEC_GROUP) == 0) group = elf_group_name (sec); else if (abfd != NULL && bfd_get_flavour (abfd) == bfd_target_coff_flavour && (ci = bfd_coff_get_comdat_section (sec->owner, sec)) != NULL) group = ci->name; if (group != NULL) fprintf (fp, "[%s]", group); } else if (*fmt == 'B') { /* filename from a bfd */ bfd *abfd = (bfd *) args[arg_no].p; fmt++; ++arg_count; if (abfd == NULL) fprintf (fp, "%s generated", program_name); else if (abfd->my_archive != NULL && !bfd_is_thin_archive (abfd->my_archive)) fprintf (fp, "%s(%s)", abfd->my_archive->filename, abfd->filename); else fprintf (fp, "%s", abfd->filename); } else if (*fmt == 'I') { /* filename from a lang_input_statement_type */ lang_input_statement_type *i; fmt++; i = (lang_input_statement_type *) args[arg_no].p; ++arg_count; if (i->the_bfd != NULL && i->the_bfd->my_archive != NULL && !bfd_is_thin_archive (i->the_bfd->my_archive)) fprintf (fp, "(%s)%s", i->the_bfd->my_archive->filename, i->local_sym_name); else fprintf (fp, "%s", i->filename); } else if (*fmt == 'R') { /* Print all that's interesting about a relent. */ arelent *relent = (arelent *) args[arg_no].p; fmt++; ++arg_count; lfinfo (fp, "%s+0x%v (type %s)", (*(relent->sym_ptr_ptr))->name, relent->addend, relent->howto->name); } else if (*fmt == 'S') { /* Print script file and linenumber. */ etree_type node; etree_type *tp = (etree_type *) args[arg_no].p; fmt++; ++arg_count; if (tp == NULL) { tp = &node; tp->type.filename = ldlex_filename (); tp->type.lineno = lineno; } if (tp->type.filename != NULL) fprintf (fp, "%s:%u", tp->type.filename, tp->type.lineno); } else if (*fmt == 'T') { /* Symbol name. */ const char *name = (const char *) args[arg_no].p; fmt++; ++arg_count; if (name == NULL || *name == 0) { fprintf (fp, _("no symbol")); break; } else if (demangling) { char *demangled; demangled = bfd_demangle (link_info.output_bfd, name, DMGL_ANSI | DMGL_PARAMS); if (demangled != NULL) { fprintf (fp, "%s", demangled); free (demangled); break; } } fprintf (fp, "%s", name); } else { /* native (host) void* pointer, like printf */ fprintf (fp, "%p", args[arg_no].p); ++arg_count; } break; case 's': /* arbitrary string, like printf */ fprintf (fp, "%s", (char *) args[arg_no].p); ++arg_count; break; case 'd': /* integer, like printf */ fprintf (fp, "%d", args[arg_no].i); ++arg_count; break; case 'u': /* unsigned integer, like printf */ fprintf (fp, "%u", args[arg_no].i); ++arg_count; break; case 'l': if (*fmt == 'd') { fprintf (fp, "%ld", args[arg_no].l); ++arg_count; ++fmt; break; } else if (*fmt == 'u') { fprintf (fp, "%lu", args[arg_no].l); ++arg_count; ++fmt; break; } /* Fallthru */ default: fprintf (fp, "%%%c", fmt[-1]); break; } } } if (is_warning && config.fatal_warnings) config.make_executable = FALSE; if (fatal) xexit (1); }