/* * Program entry point, command line parsing * * Copyright (C) 2001-2007 Peter Johnson * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS'' * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include #include #include #include #include #ifdef HAVE_LIBGEN_H #include #endif #include "yasm-options.h" #ifdef CMAKE_BUILD #include "yasm-plugin.h" #endif #include "license.c" /* Preprocess-only buffer size */ #define PREPROC_BUF_SIZE 16384 /*@null@*/ /*@only@*/ static char *obj_filename = NULL, *in_filename = NULL; /*@null@*/ /*@only@*/ static char *global_prefix = NULL, *global_suffix = NULL; /*@null@*/ /*@only@*/ static char *list_filename = NULL, *map_filename = NULL; /*@null@*/ /*@only@*/ static char *machine_name = NULL; static int special_options = 0; /*@null@*/ /*@dependent@*/ static yasm_arch *cur_arch = NULL; /*@null@*/ /*@dependent@*/ static const yasm_arch_module * cur_arch_module = NULL; /*@null@*/ /*@dependent@*/ static const yasm_parser_module * cur_parser_module = NULL; /*@null@*/ /*@dependent@*/ static yasm_preproc *cur_preproc = NULL; /*@null@*/ /*@dependent@*/ static const yasm_preproc_module * cur_preproc_module = NULL; /*@null@*/ static char *objfmt_keyword = NULL; /*@null@*/ /*@dependent@*/ static const yasm_objfmt_module * cur_objfmt_module = NULL; /*@null@*/ /*@dependent@*/ static const yasm_dbgfmt_module * cur_dbgfmt_module = NULL; /*@null@*/ /*@dependent@*/ static yasm_listfmt *cur_listfmt = NULL; /*@null@*/ /*@dependent@*/ static const yasm_listfmt_module * cur_listfmt_module = NULL; static int preproc_only = 0; static unsigned int force_strict = 0; static int generate_make_dependencies = 0; static int warning_error = 0; /* warnings being treated as errors */ static FILE *errfile; /*@null@*/ /*@only@*/ static char *error_filename = NULL; static enum { EWSTYLE_GNU = 0, EWSTYLE_VC } ewmsg_style = EWSTYLE_GNU; /*@null@*/ /*@dependent@*/ static FILE *open_file(const char *filename, const char *mode); static void check_errors(/*@only@*/ yasm_errwarns *errwarns, /*@only@*/ yasm_object *object, /*@only@*/ yasm_linemap *linemap); static void cleanup(/*@null@*/ /*@only@*/ yasm_object *object); /* Forward declarations: cmd line parser handlers */ static int opt_special_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_arch_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_parser_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_preproc_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_objfmt_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_dbgfmt_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_listfmt_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_listfile_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_objfile_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_mapfile_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_machine_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_strict_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_warning_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_error_file(char *cmd, /*@null@*/ char *param, int extra); static int opt_error_stdout(char *cmd, /*@null@*/ char *param, int extra); static int preproc_only_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_include_option(char *cmd, /*@null@*/ char *param, int extra); static int opt_preproc_option(char *cmd, /*@null@*/ char *param, int extra); static int opt_ewmsg_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_makedep_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_prefix_handler(char *cmd, /*@null@*/ char *param, int extra); static int opt_suffix_handler(char *cmd, /*@null@*/ char *param, int extra); #ifdef CMAKE_BUILD static int opt_plugin_handler(char *cmd, /*@null@*/ char *param, int extra); #endif static /*@only@*/ char *replace_extension(const char *orig, /*@null@*/ const char *ext, const char *def); static void print_error(const char *fmt, ...); static /*@exits@*/ void handle_yasm_int_error(const char *file, unsigned int line, const char *message); static /*@exits@*/ void handle_yasm_fatal(const char *message, va_list va); static const char *handle_yasm_gettext(const char *msgid); static void print_yasm_error(const char *filename, unsigned long line, const char *msg, /*@null@*/ const char *xref_fn, unsigned long xref_line, /*@null@*/ const char *xref_msg); static void print_yasm_warning(const char *filename, unsigned long line, const char *msg); static void apply_preproc_builtins(void); static void apply_preproc_standard_macros(const yasm_stdmac *stdmacs); static void apply_preproc_saved_options(void); static void print_list_keyword_desc(const char *name, const char *keyword); /* values for special_options */ #define SPECIAL_SHOW_HELP 0x01 #define SPECIAL_SHOW_VERSION 0x02 #define SPECIAL_SHOW_LICENSE 0x04 #define SPECIAL_LISTED 0x08 /* command line options */ static opt_option options[] = { { 0, "version", 0, opt_special_handler, SPECIAL_SHOW_VERSION, N_("show version text"), NULL }, { 0, "license", 0, opt_special_handler, SPECIAL_SHOW_LICENSE, N_("show license text"), NULL }, { 'h', "help", 0, opt_special_handler, SPECIAL_SHOW_HELP, N_("show help text"), NULL }, { 'a', "arch", 1, opt_arch_handler, 0, N_("select architecture (list with -a help)"), N_("arch") }, { 'p', "parser", 1, opt_parser_handler, 0, N_("select parser (list with -p help)"), N_("parser") }, { 'r', "preproc", 1, opt_preproc_handler, 0, N_("select preprocessor (list with -r help)"), N_("preproc") }, { 'f', "oformat", 1, opt_objfmt_handler, 0, N_("select object format (list with -f help)"), N_("format") }, { 'g', "dformat", 1, opt_dbgfmt_handler, 0, N_("select debugging format (list with -g help)"), N_("debug") }, { 'L', "lformat", 1, opt_listfmt_handler, 0, N_("select list format (list with -L help)"), N_("list") }, { 'l', "list", 1, opt_listfile_handler, 0, N_("name of list-file output"), N_("listfile") }, { 'o', "objfile", 1, opt_objfile_handler, 0, N_("name of object-file output"), N_("filename") }, { 0, "mapfile", 1, opt_mapfile_handler, 0, N_("name of map-file output"), N_("filename") }, { 'm', "machine", 1, opt_machine_handler, 0, N_("select machine (list with -m help)"), N_("machine") }, { 0, "force-strict", 0, opt_strict_handler, 0, N_("treat all sized operands as if `strict' was used"), NULL }, { 'w', NULL, 0, opt_warning_handler, 1, N_("inhibits warning messages"), NULL }, { 'W', NULL, 0, opt_warning_handler, 0, N_("enables/disables warning"), NULL }, { 'M', NULL, 0, opt_makedep_handler, 0, N_("generate Makefile dependencies on stdout"), NULL }, { 'E', NULL, 1, opt_error_file, 0, N_("redirect error messages to file"), N_("file") }, { 's', NULL, 0, opt_error_stdout, 0, N_("redirect error messages to stdout"), NULL }, { 'e', "preproc-only", 0, preproc_only_handler, 0, N_("preprocess only (writes output to stdout by default)"), NULL }, { 'i', NULL, 1, opt_include_option, 0, N_("add include path"), N_("path") }, { 'I', NULL, 1, opt_include_option, 0, N_("add include path"), N_("path") }, { 'P', NULL, 1, opt_preproc_option, 0, N_("pre-include file"), N_("filename") }, { 'd', NULL, 1, opt_preproc_option, 1, N_("pre-define a macro, optionally to value"), N_("macro[=value]") }, { 'D', NULL, 1, opt_preproc_option, 1, N_("pre-define a macro, optionally to value"), N_("macro[=value]") }, { 'u', NULL, 1, opt_preproc_option, 2, N_("undefine a macro"), N_("macro") }, { 'U', NULL, 1, opt_preproc_option, 2, N_("undefine a macro"), N_("macro") }, { 'X', NULL, 1, opt_ewmsg_handler, 0, N_("select error/warning message style (`gnu' or `vc')"), N_("style") }, { 0, "prefix", 1, opt_prefix_handler, 0, N_("prepend argument to name of all external symbols"), N_("prefix") }, { 0, "suffix", 1, opt_suffix_handler, 0, N_("append argument to name of all external symbols"), N_("suffix") }, { 0, "postfix", 1, opt_suffix_handler, 0, N_("append argument to name of all external symbols"), N_("suffix") }, #ifdef CMAKE_BUILD { 'N', "plugin", 1, opt_plugin_handler, 0, N_("load plugin module"), N_("plugin") }, #endif }; /* version message */ /*@observer@*/ static const char *version_msg[] = { PACKAGE_STRING, "Compiled on " __DATE__ ".", "Copyright (c) 2001-2011 Peter Johnson and other Yasm developers.", "Run yasm --license for licensing overview and summary." }; /* help messages */ /*@observer@*/ static const char *help_head = N_( "usage: yasm [option]* file\n" "Options:\n"); /*@observer@*/ static const char *help_tail = N_( "\n" "Files are asm sources to be assembled.\n" "\n" "Sample invocation:\n" " yasm -f elf -o object.o source.asm\n" "\n" "Report bugs to bug-yasm@tortall.net\n"); /* parsed command line storage until appropriate modules have been loaded */ typedef STAILQ_HEAD(constcharparam_head, constcharparam) constcharparam_head; typedef struct constcharparam { STAILQ_ENTRY(constcharparam) link; const char *param; int id; } constcharparam; static constcharparam_head preproc_options; static int do_preproc_only(void) { yasm_linemap *linemap; char *preproc_buf; size_t got; const char *base_filename; FILE *out = NULL; yasm_errwarns *errwarns = yasm_errwarns_create(); /* Initialize line map */ linemap = yasm_linemap_create(); yasm_linemap_set(linemap, in_filename, 0, 1, 1); /* Default output to stdout if not specified or generating dependency makefiles */ if (!obj_filename || generate_make_dependencies) { out = stdout; /* determine the object filename if not specified, but we need a file name for the makefile rule */ if (generate_make_dependencies && !obj_filename) { if (in_filename == NULL) /* Default to yasm.out if no obj filename specified */ obj_filename = yasm__xstrdup("yasm.out"); else { /* replace (or add) extension to base filename */ yasm__splitpath(in_filename, &base_filename); if (base_filename[0] == '\0') obj_filename = yasm__xstrdup("yasm.out"); else obj_filename = replace_extension(base_filename, cur_objfmt_module->extension, "yasm.out"); } } } else { /* Open output (object) file */ out = open_file(obj_filename, "wt"); if (!out) return EXIT_FAILURE; } /* Create preprocessor */ cur_preproc = yasm_preproc_create(cur_preproc_module, in_filename, NULL, linemap, errwarns); /* Apply macros */ apply_preproc_builtins(); apply_preproc_standard_macros(cur_parser_module->stdmacs); apply_preproc_standard_macros(cur_objfmt_module->stdmacs); apply_preproc_saved_options(); /* Pre-process until done */ if (generate_make_dependencies) { size_t totlen; preproc_buf = yasm_xmalloc(PREPROC_BUF_SIZE); fprintf(stdout, "%s: %s", obj_filename, in_filename); totlen = strlen(obj_filename)+2+strlen(in_filename); while ((got = yasm_preproc_get_included_file(cur_preproc, preproc_buf, PREPROC_BUF_SIZE)) != 0) { totlen += got; if (totlen > 72) { fputs(" \\\n ", stdout); totlen = 2; } fputc(' ', stdout); fwrite(preproc_buf, got, 1, stdout); } fputc('\n', stdout); yasm_xfree(preproc_buf); } else { while ((preproc_buf = yasm_preproc_get_line(cur_preproc)) != NULL) { fputs(preproc_buf, out); fputc('\n', out); yasm_xfree(preproc_buf); } } if (out != stdout) fclose(out); if (yasm_errwarns_num_errors(errwarns, warning_error) > 0) { yasm_errwarns_output_all(errwarns, linemap, warning_error, print_yasm_error, print_yasm_warning); if (out != stdout) remove(obj_filename); yasm_linemap_destroy(linemap); yasm_errwarns_destroy(errwarns); cleanup(NULL); return EXIT_FAILURE; } yasm_errwarns_output_all(errwarns, linemap, warning_error, print_yasm_error, print_yasm_warning); yasm_linemap_destroy(linemap); yasm_errwarns_destroy(errwarns); cleanup(NULL); return EXIT_SUCCESS; } static int do_assemble(void) { yasm_object *object; const char *base_filename; /*@null@*/ FILE *obj = NULL; yasm_arch_create_error arch_error; yasm_linemap *linemap; yasm_errwarns *errwarns = yasm_errwarns_create(); int i, matched; const char *machine; /* Initialize line map */ linemap = yasm_linemap_create(); yasm_linemap_set(linemap, in_filename, 0, 1, 1); /* determine the object filename if not specified */ if (!obj_filename) { if (in_filename == NULL) /* Default to yasm.out if no obj filename specified */ obj_filename = yasm__xstrdup("yasm.out"); else { /* replace (or add) extension to base filename */ yasm__splitpath(in_filename, &base_filename); if (base_filename[0] == '\0') obj_filename = yasm__xstrdup("yasm.out"); else obj_filename = replace_extension(base_filename, cur_objfmt_module->extension, "yasm.out"); } } /* Set up architecture using machine and parser. */ if (!machine_name) { /* If we're using x86 and the default objfmt bits is 64, default the * machine to amd64. When we get more arches with multiple machines, * we should do this in a more modular fashion. */ if (strcmp(cur_arch_module->keyword, "x86") == 0 && cur_objfmt_module->default_x86_mode_bits == 64) machine_name = yasm__xstrdup("amd64"); else machine_name = yasm__xstrdup(cur_arch_module->default_machine_keyword); } /* If we're using amd64 and the default objfmt is elfx32, change the * machine to "x32". */ if (strcmp(machine_name, "amd64") == 0 && strcmp(cur_objfmt_module->keyword, "elfx32") == 0) machine = "x32"; else machine = machine_name; cur_arch = yasm_arch_create(cur_arch_module, machine, cur_parser_module->keyword, &arch_error); if (!cur_arch) { switch (arch_error) { case YASM_ARCH_CREATE_BAD_MACHINE: print_error(_("%s: `%s' is not a valid %s for %s `%s'"), _("FATAL"), machine_name, _("machine"), _("architecture"), cur_arch_module->keyword); break; case YASM_ARCH_CREATE_BAD_PARSER: print_error(_("%s: `%s' is not a valid %s for %s `%s'"), _("FATAL"), cur_parser_module->keyword, _("parser"), _("architecture"), cur_arch_module->keyword); break; default: print_error(_("%s: unknown architecture error"), _("FATAL")); } return EXIT_FAILURE; } /* Create object */ object = yasm_object_create(in_filename, obj_filename, cur_arch, cur_objfmt_module, cur_dbgfmt_module); if (!object) { yasm_error_class eclass; unsigned long xrefline; /*@only@*/ /*@null@*/ char *estr, *xrefstr; yasm_error_fetch(&eclass, &estr, &xrefline, &xrefstr); print_error("%s: %s", _("FATAL"), estr); yasm_xfree(estr); yasm_xfree(xrefstr); cleanup(object); return EXIT_FAILURE; } /* Get a fresh copy of objfmt_module as it may have changed. */ cur_objfmt_module = ((yasm_objfmt_base *)object->objfmt)->module; /* Check to see if the requested preprocessor is in the allowed list * for the active parser. */ matched = 0; for (i=0; cur_parser_module->preproc_keywords[i]; i++) if (yasm__strcasecmp(cur_parser_module->preproc_keywords[i], cur_preproc_module->keyword) == 0) matched = 1; if (!matched) { print_error(_("%s: `%s' is not a valid %s for %s `%s'"), _("FATAL"), cur_preproc_module->keyword, _("preprocessor"), _("parser"), cur_parser_module->keyword); cleanup(object); return EXIT_FAILURE; } if (global_prefix) yasm_object_set_global_prefix(object, global_prefix); if (global_suffix) yasm_object_set_global_suffix(object, global_suffix); cur_preproc = yasm_preproc_create(cur_preproc_module, in_filename, object->symtab, linemap, errwarns); apply_preproc_builtins(); apply_preproc_standard_macros(cur_parser_module->stdmacs); apply_preproc_standard_macros(cur_objfmt_module->stdmacs); apply_preproc_saved_options(); /* Get initial x86 BITS setting from object format */ if (strcmp(cur_arch_module->keyword, "x86") == 0) { yasm_arch_set_var(cur_arch, "mode_bits", cur_objfmt_module->default_x86_mode_bits); } yasm_arch_set_var(cur_arch, "force_strict", force_strict); /* Try to enable the map file via a map NASM directive. This is * somewhat of a hack. */ if (map_filename) { const yasm_directive *dir = &cur_objfmt_module->directives[0]; matched = 0; for (; dir && dir->name; dir++) { if (yasm__strcasecmp(dir->name, "map") == 0 && yasm__strcasecmp(dir->parser, "nasm") == 0) { yasm_valparamhead vps; yasm_valparam *vp; matched = 1; yasm_vps_initialize(&vps); vp = yasm_vp_create_string(NULL, yasm__xstrdup(map_filename)); yasm_vps_append(&vps, vp); dir->handler(object, &vps, NULL, 0); yasm_vps_delete(&vps); } } if (!matched) { print_error( _("warning: object format `%s' does not support map files"), cur_objfmt_module->keyword); } } /* Parse! */ cur_parser_module->do_parse(object, cur_preproc, list_filename != NULL, linemap, errwarns); check_errors(errwarns, object, linemap); /* Finalize parse */ yasm_object_finalize(object, errwarns); check_errors(errwarns, object, linemap); /* Optimize */ yasm_object_optimize(object, errwarns); check_errors(errwarns, object, linemap); /* generate any debugging information */ yasm_dbgfmt_generate(object, linemap, errwarns); check_errors(errwarns, object, linemap); /* open the object file for output (if not already opened by dbg objfmt) */ if (!obj && strcmp(cur_objfmt_module->keyword, "dbg") != 0) { obj = open_file(obj_filename, "wb"); if (!obj) { cleanup(object); return EXIT_FAILURE; } } /* Write the object file */ yasm_objfmt_output(object, obj?obj:stderr, strcmp(cur_dbgfmt_module->keyword, "null"), errwarns); /* Close object file */ if (obj) fclose(obj); /* If we had an error at this point, we also need to delete the output * object file (to make sure it's not left newer than the source). */ if (yasm_errwarns_num_errors(errwarns, warning_error) > 0) remove(obj_filename); check_errors(errwarns, object, linemap); /* Open and write the list file */ if (list_filename) { FILE *list = open_file(list_filename, "wt"); if (!list) { cleanup(object); return EXIT_FAILURE; } /* Initialize the list format */ cur_listfmt = yasm_listfmt_create(cur_listfmt_module, in_filename, obj_filename); yasm_listfmt_output(cur_listfmt, list, linemap, cur_arch); fclose(list); } yasm_errwarns_output_all(errwarns, linemap, warning_error, print_yasm_error, print_yasm_warning); yasm_linemap_destroy(linemap); yasm_errwarns_destroy(errwarns); cleanup(object); return EXIT_SUCCESS; } /* main function */ /*@-globstate -unrecog@*/ int main(int argc, char *argv[]) { size_t i; errfile = stderr; #if defined(HAVE_SETLOCALE) && defined(HAVE_LC_MESSAGES) setlocale(LC_MESSAGES, ""); #endif #if defined(LOCALEDIR) bindtextdomain(PACKAGE, LOCALEDIR); #endif textdomain(PACKAGE); /* Initialize errwarn handling */ yasm_internal_error_ = handle_yasm_int_error; yasm_fatal = handle_yasm_fatal; yasm_gettext_hook = handle_yasm_gettext; yasm_errwarn_initialize(); /* Initialize BitVector (needed for intnum/floatnum). */ if (BitVector_Boot() != ErrCode_Ok) { print_error(_("%s: could not initialize BitVector"), _("FATAL")); return EXIT_FAILURE; } /* Initialize intnum and floatnum */ yasm_intnum_initialize(); yasm_floatnum_initialize(); #ifdef CMAKE_BUILD /* Load standard modules */ if (!load_plugin("yasmstd")) { print_error(_("%s: could not load standard modules"), _("FATAL")); return EXIT_FAILURE; } #endif /* Initialize parameter storage */ STAILQ_INIT(&preproc_options); if (parse_cmdline(argc, argv, options, NELEMS(options), print_error)) return EXIT_FAILURE; switch (special_options) { case SPECIAL_SHOW_HELP: /* Does gettext calls internally */ help_msg(help_head, help_tail, options, NELEMS(options)); return EXIT_SUCCESS; case SPECIAL_SHOW_VERSION: for (i=0; imachines; printf(_("Available %s for %s `%s':\n"), _("machines"), _("architecture"), cur_arch_module->keyword); while (m->keyword && m->name) { print_list_keyword_desc(m->name, m->keyword); m++; } return EXIT_SUCCESS; } /* Default to NASM as the parser */ if (!cur_parser_module) { cur_parser_module = yasm_load_parser("nasm"); if (!cur_parser_module) { print_error(_("%s: could not load default %s"), _("FATAL"), _("parser")); cleanup(NULL); return EXIT_FAILURE; } } /* If not already specified, default to the parser's default preproc. */ if (!cur_preproc_module) { cur_preproc_module = yasm_load_preproc(cur_parser_module->default_preproc_keyword); if (!cur_preproc_module) { print_error(_("%s: could not load default %s"), _("FATAL"), _("preprocessor")); cleanup(NULL); return EXIT_FAILURE; } } /* Determine input filename and open input file. */ if (!in_filename) { print_error(_("No input files specified")); return EXIT_FAILURE; } /* handle preproc-only case here */ if (preproc_only) return do_preproc_only(); /* If list file enabled, make sure we have a list format loaded. */ if (list_filename) { /* If not already specified, default to nasm as the list format. */ if (!cur_listfmt_module) { cur_listfmt_module = yasm_load_listfmt("nasm"); if (!cur_listfmt_module) { print_error(_("%s: could not load default %s"), _("FATAL"), _("list format")); return EXIT_FAILURE; } } } /* If not already specified, default to null as the debug format. */ if (!cur_dbgfmt_module) { cur_dbgfmt_module = yasm_load_dbgfmt("null"); if (!cur_dbgfmt_module) { print_error(_("%s: could not load default %s"), _("FATAL"), _("debug format")); return EXIT_FAILURE; } } return do_assemble(); } /*@=globstate =unrecog@*/ /* Open the object file. Returns 0 on failure. */ static FILE * open_file(const char *filename, const char *mode) { FILE *f; f = fopen(filename, mode); if (!f) print_error(_("could not open file `%s'"), filename); return f; } static void check_errors(yasm_errwarns *errwarns, yasm_object *object, yasm_linemap *linemap) { if (yasm_errwarns_num_errors(errwarns, warning_error) > 0) { yasm_errwarns_output_all(errwarns, linemap, warning_error, print_yasm_error, print_yasm_warning); yasm_linemap_destroy(linemap); yasm_errwarns_destroy(errwarns); cleanup(object); exit(EXIT_FAILURE); } } /* Define DO_FREE to 1 to enable deallocation of all data structures. * Useful for detecting memory leaks, but slows down execution unnecessarily * (as the OS will free everything we miss here). */ #define DO_FREE 1 /* Cleans up all allocated structures. */ static void cleanup(yasm_object *object) { if (DO_FREE) { if (cur_listfmt) yasm_listfmt_destroy(cur_listfmt); if (cur_preproc) yasm_preproc_destroy(cur_preproc); if (object) yasm_object_destroy(object); yasm_floatnum_cleanup(); yasm_intnum_cleanup(); yasm_errwarn_cleanup(); BitVector_Shutdown(); } if (DO_FREE) { if (in_filename) yasm_xfree(in_filename); if (obj_filename) yasm_xfree(obj_filename); if (list_filename) yasm_xfree(list_filename); if (map_filename) yasm_xfree(map_filename); if (machine_name) yasm_xfree(machine_name); if (objfmt_keyword) yasm_xfree(objfmt_keyword); } if (errfile != stderr && errfile != stdout) fclose(errfile); #ifdef CMAKE_BUILD unload_plugins(); #endif } /* * Command line options handlers */ int not_an_option_handler(char *param) { if (in_filename) { print_error( _("warning: can open only one input file, only the last file will be processed")); yasm_xfree(in_filename); } in_filename = yasm__xstrdup(param); return 0; } int other_option_handler(char *option) { /* Accept, but ignore, -O and -Onnn, for compatibility with NASM. */ if (option[0] == '-' && option[1] == 'O') { int n = 2; for (;;) { if (option[n] == '\0') return 0; if (!isdigit(option[n])) return 1; n++; } } return 1; } static int opt_special_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param, int extra) { if (special_options == 0) special_options = extra; return 0; } static int opt_arch_handler(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra) { assert(param != NULL); cur_arch_module = yasm_load_arch(param); if (!cur_arch_module) { if (!strcmp("help", param)) { printf(_("Available yasm %s:\n"), _("architectures")); yasm_list_arch(print_list_keyword_desc); special_options = SPECIAL_LISTED; return 0; } print_error(_("%s: unrecognized %s `%s'"), _("FATAL"), _("architecture"), param); exit(EXIT_FAILURE); } return 0; } static int opt_parser_handler(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra) { assert(param != NULL); cur_parser_module = yasm_load_parser(param); if (!cur_parser_module) { if (!strcmp("help", param)) { printf(_("Available yasm %s:\n"), _("parsers")); yasm_list_parser(print_list_keyword_desc); special_options = SPECIAL_LISTED; return 0; } print_error(_("%s: unrecognized %s `%s'"), _("FATAL"), _("parser"), param); exit(EXIT_FAILURE); } return 0; } static int opt_preproc_handler(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra) { assert(param != NULL); cur_preproc_module = yasm_load_preproc(param); if (!cur_preproc_module) { if (!strcmp("help", param)) { printf(_("Available yasm %s:\n"), _("preprocessors")); yasm_list_preproc(print_list_keyword_desc); special_options = SPECIAL_LISTED; return 0; } print_error(_("%s: unrecognized %s `%s'"), _("FATAL"), _("preprocessor"), param); exit(EXIT_FAILURE); } return 0; } static int opt_objfmt_handler(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra) { size_t i; assert(param != NULL); cur_objfmt_module = yasm_load_objfmt(param); if (!cur_objfmt_module) { if (!strcmp("help", param)) { printf(_("Available yasm %s:\n"), _("object formats")); yasm_list_objfmt(print_list_keyword_desc); special_options = SPECIAL_LISTED; return 0; } print_error(_("%s: unrecognized %s `%s'"), _("FATAL"), _("object format"), param); exit(EXIT_FAILURE); } if (objfmt_keyword) yasm_xfree(objfmt_keyword); objfmt_keyword = yasm__xstrdup(param); for (i=0; iparam = param; cp->id = extra; STAILQ_INSERT_TAIL(&preproc_options, cp, link); return 0; } static int opt_ewmsg_handler(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra) { if (yasm__strcasecmp(param, "gnu") == 0 || yasm__strcasecmp(param, "gcc") == 0) { ewmsg_style = EWSTYLE_GNU; } else if (yasm__strcasecmp(param, "vc") == 0) { ewmsg_style = EWSTYLE_VC; } else print_error(_("warning: unrecognized message style `%s'"), param); return 0; } static int opt_makedep_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param, /*@unused@*/ int extra) { /* Also set preproc_only to 1, we don't want to generate code */ preproc_only = 1; generate_make_dependencies = 1; return 0; } static int opt_prefix_handler(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra) { if (global_prefix) yasm_xfree(global_prefix); assert(param != NULL); global_prefix = yasm__xstrdup(param); return 0; } static int opt_suffix_handler(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra) { if (global_suffix) yasm_xfree(global_suffix); assert(param != NULL); global_suffix = yasm__xstrdup(param); return 0; } #ifdef CMAKE_BUILD static int opt_plugin_handler(/*@unused@*/ char *cmd, char *param, /*@unused@*/ int extra) { if (!load_plugin(param)) print_error(_("warning: could not load plugin `%s'"), param); return 0; } #endif static void apply_preproc_builtins() { char *predef; /* Define standard YASM assembly-time macro constants */ predef = yasm_xmalloc(strlen("__YASM_OBJFMT__=") + strlen(objfmt_keyword) + 1); strcpy(predef, "__YASM_OBJFMT__="); strcat(predef, objfmt_keyword); yasm_preproc_define_builtin(cur_preproc, predef); yasm_xfree(predef); } static void apply_preproc_standard_macros(const yasm_stdmac *stdmacs) { int i, matched; if (!stdmacs) return; matched = -1; for (i=0; stdmacs[i].parser; i++) if (yasm__strcasecmp(stdmacs[i].parser, cur_parser_module->keyword) == 0 && yasm__strcasecmp(stdmacs[i].preproc, cur_preproc_module->keyword) == 0) matched = i; if (matched >= 0 && stdmacs[matched].macros) yasm_preproc_add_standard(cur_preproc, stdmacs[matched].macros); } static void apply_preproc_saved_options() { constcharparam *cp, *cpnext; void (*funcs[3])(yasm_preproc *, const char *); funcs[0] = cur_preproc_module->add_include_file; funcs[1] = cur_preproc_module->predefine_macro; funcs[2] = cur_preproc_module->undefine_macro; STAILQ_FOREACH(cp, &preproc_options, link) { if (0 <= cp->id && cp->id < 3 && funcs[cp->id]) funcs[cp->id](cur_preproc, cp->param); } cp = STAILQ_FIRST(&preproc_options); while (cp != NULL) { cpnext = STAILQ_NEXT(cp, link); yasm_xfree(cp); cp = cpnext; } STAILQ_INIT(&preproc_options); } /* Replace extension on a filename (or append one if none is present). * If output filename would be identical to input (same extension out as in), * returns (copy of) def. * A NULL ext means the trailing '.' should NOT be included, whereas a "" ext * means the trailing '.' should be included. */ static char * replace_extension(const char *orig, /*@null@*/ const char *ext, const char *def) { char *out, *outext; size_t deflen, outlen; /* allocate enough space for full existing name + extension */ outlen = strlen(orig) + 2; if (ext) outlen += strlen(ext) + 1; deflen = strlen(def) + 1; if (outlen < deflen) outlen = deflen; out = yasm_xmalloc(outlen); strcpy(out, orig); outext = strrchr(out, '.'); if (outext) { /* Existing extension: make sure it's not the same as the replacement * (as we don't want to overwrite the source file). */ outext++; /* advance past '.' */ if (ext && strcmp(outext, ext) == 0) { outext = NULL; /* indicate default should be used */ print_error( _("file name already ends in `.%s': output will be in `%s'"), ext, def); } } else { /* No extension: make sure the output extension is not empty * (again, we don't want to overwrite the source file). */ if (!ext) print_error( _("file name already has no extension: output will be in `%s'"), def); else { outext = strrchr(out, '\0'); /* point to end of the string */ *outext++ = '.'; /* append '.' */ } } /* replace extension or use default name */ if (outext) { if (!ext) { /* Back up and replace '.' with string terminator */ outext--; *outext = '\0'; } else strcpy(outext, ext); } else strcpy(out, def); return out; } void print_list_keyword_desc(const char *name, const char *keyword) { printf("%4s%-12s%s\n", "", keyword, name); } static void print_error(const char *fmt, ...) { va_list va; fprintf(errfile, "yasm: "); va_start(va, fmt); vfprintf(errfile, fmt, va); va_end(va); fputc('\n', errfile); } static /*@exits@*/ void handle_yasm_int_error(const char *file, unsigned int line, const char *message) { fprintf(stderr, _("INTERNAL ERROR at %s, line %u: %s\n"), file, line, gettext(message)); #ifdef HAVE_ABORT abort(); #else exit(EXIT_FAILURE); #endif } static /*@exits@*/ void handle_yasm_fatal(const char *fmt, va_list va) { fprintf(errfile, "yasm: %s: ", _("FATAL")); vfprintf(errfile, gettext(fmt), va); fputc('\n', errfile); exit(EXIT_FAILURE); } static const char * handle_yasm_gettext(const char *msgid) { return gettext(msgid); } static const char *fmt[2] = { "%s:%lu: %s%s\n", /* GNU */ "%s(%lu) : %s%s\n" /* VC */ }; static const char *fmt_noline[2] = { "%s: %s%s\n", /* GNU */ "%s : %s%s\n" /* VC */ }; static void print_yasm_error(const char *filename, unsigned long line, const char *msg, const char *xref_fn, unsigned long xref_line, const char *xref_msg) { if (line) fprintf(errfile, fmt[ewmsg_style], filename, line, _("error: "), msg); else fprintf(errfile, fmt_noline[ewmsg_style], filename, _("error: "), msg); if (xref_fn && xref_msg) { if (xref_line) fprintf(errfile, fmt[ewmsg_style], xref_fn, xref_line, _("error: "), xref_msg); else fprintf(errfile, fmt_noline[ewmsg_style], xref_fn, _("error: "), xref_msg); } } static void print_yasm_warning(const char *filename, unsigned long line, const char *msg) { if (line) fprintf(errfile, fmt[ewmsg_style], filename, line, _("warning: "), msg); else fprintf(errfile, fmt_noline[ewmsg_style], filename, _("warning: "), msg); }