blob: d1f0d521fafd4d2ecffdb9775e320166ed8905bf [file] [log] [blame]
/*
* Program entry point, command line parsing
*
* Copyright (C) 2001-2008 Peter Johnson
* Copyright (C) 2007-2008 Samuel Thibault
*
* 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 <util.h>
#include <ctype.h>
#include <libyasm/compat-queue.h>
#include <libyasm/bitvect.h>
#include <libyasm.h>
#ifdef HAVE_LIBGEN_H
#include <libgen.h>
#endif
#include "tasm-options.h"
#ifdef CMAKE_BUILD
#include "yasm-plugin.h"
#endif
#include "license.c"
#define DEFAULT_OBJFMT_MODULE "bin"
/*@null@*/ /*@only@*/ static char *obj_filename = NULL, *in_filename = NULL;
/*@null@*/ /*@only@*/ static char *list_filename = NULL, *xref_filename = NULL;
/*@null@*/ /*@only@*/ static char *machine_name = NULL;
static int special_options = 0;
static int segment_ordering = 0;
static int cross_reference = 0;
static int floating_point = 0;
static int listing = 0;
static int expanded_listing = 0;
static int case_sensitivity = 0;
static int valid_length = -1;
/*@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 warning_error = 0; /* warnings being treated as errors */
static FILE *errfile;
/*@null@*/ /*@only@*/ static char *error_filename = NULL;
/*@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_segment_ordering_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_cross_reference_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_floating_point_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_ignore(char *cmd, /*@null@*/ char *param, int extra);
static int opt_listing_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_case_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_valid_length_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_warning_handler(char *cmd, /*@null@*/ char *param, int extra);
static int opt_preproc_option(char *cmd, /*@null@*/ char *param, int extra);
static int opt_exe_handler(char *cmd, /*@null@*/ char *param, int extra);
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 SEGMENT_ORDERING_ALPHABETIC 0x01
#define SEGMENT_ORDERING_SOURCE 0x02
#define FP_EMULATED 0x01
#define FP_REAL 0x02
#define CASE_ALL 0x01
#define CASE_GLOBALS 0x02
#define CASE_NONE 0x04
#define DEBUG_FULL 0x01
#define DEBUG_LINES 0x02
#define DEBUG_NONE 0x04
/* command line options */
static opt_option options[] =
{
{ "version", 0, opt_special_handler, SPECIAL_SHOW_VERSION,
N_("show version text"), NULL },
{ "license", 0, opt_special_handler, SPECIAL_SHOW_LICENSE,
N_("show license text"), NULL },
{ "a", 0, opt_segment_ordering_handler, SEGMENT_ORDERING_ALPHABETIC,
N_("Alphabetic segment ordering"), NULL },
{ "s", 0, opt_segment_ordering_handler, SEGMENT_ORDERING_SOURCE,
N_("Source segment ordering"), NULL },
{ "c", 0, opt_cross_reference_handler, 0,
N_("Generate cross-reference in listing"), NULL },
{ "d", 1, opt_preproc_option, 2,
N_("pre-define a macro, optionally to value"), N_("macro[=value]") },
{ "e", 0, opt_floating_point_handler, FP_EMULATED,
N_("Emulated floating-point instructions (not supported)"), NULL },
{ "r", 0, opt_floating_point_handler, FP_REAL,
N_("Real floating-point instructions"), NULL },
{ "h", 0, opt_special_handler, SPECIAL_SHOW_HELP,
N_("show help text"), NULL },
{ "?", 0, opt_special_handler, SPECIAL_SHOW_HELP,
N_("show help text"), NULL },
{ "i", 1, opt_preproc_option, 0,
N_("add include path"), N_("path") },
{ "j", 1, opt_ignore, 0,
N_("Jam in an assemble directive CMD (eg. /jIDEAL) (not supported)"), NULL },
{ "k", 1, opt_ignore, 0,
N_("Hash table capacity (ignored)"), N_("# symbols") },
{ "l", 0, opt_listing_handler, 0,
N_("Generate listing"), N_("l=normal listing, la=expanded listing") },
{ "ml", 0, opt_case_handler, CASE_ALL,
N_("Case sensitivity on all symbols"), NULL },
{ "mx", 0, opt_case_handler, CASE_GLOBALS,
N_("Case sensitivity on global symbols"), NULL },
{ "mu", 0, opt_case_handler, CASE_NONE,
N_("No case sensitivity on symbols"), NULL },
{ "mv", 0, opt_valid_length_handler, 0,
N_("Set maximum valid length for symbols"), N_("length") },
{ "m", 1, opt_ignore, 0,
N_("Allow multiple passes to resolve forward reference (ignored)"), N_("number of passes") },
{ "n", 0, opt_ignore, 0,
N_("Suppress symbol tables in listing"), NULL },
{ "o", 0, opt_ignore, 0,
N_("Object code"), N_("os: standard, o: standard w/overlays, op: Phar Lap, oi: IBM") },
{ "p", 0, opt_ignore, 0,
N_("Check for code segment overrides in protected mode"), NULL },
{ "q", 0, opt_ignore, 0,
N_("Suppress OBJ records not needed for linking (ignored)"), NULL },
{ "t", 0, opt_ignore, 0,
N_("Suppress messages if successful assembly"), NULL },
{ "u", 0, opt_ignore, 0,
N_("Set version emulation"), N_("Version") },
{ "w", 1, opt_warning_handler, 0,
N_("Set warning level"), N_("w0=none, w1=w2=warnings on, w-xxx/w+xxx=disable/enable warning xxx") },
{ "x", 0, opt_ignore, 0,
N_("Include false conditionals in listing"), NULL },
{ "zi", 0, opt_ignore, DEBUG_FULL,
N_("Full debug info"), NULL },
{ "zd", 0, opt_ignore, DEBUG_LINES,
N_("Line numbers debug info"), NULL },
{ "zn", 0, opt_ignore, DEBUG_NONE,
N_("No debug info"), NULL },
{ "z", 0, opt_ignore, 0,
N_("Display source line with error message (ignored)"), NULL },
{ "b", 0, opt_exe_handler, 0,
N_("Build a (very) basic .exe file"), NULL },
};
/* version message */
/*@observer@*/ static const char *version_msg[] = {
PACKAGE_STRING,
"Copyright (c) 2001-2010 Peter Johnson and other Yasm developers.",
"Run yasm --license for licensing overview and summary."
};
/* help messages */
/*@observer@*/ static const char *help_head = N_(
"usage: tasm [option]* source [,object] [,listing] [,xref] \n"
"Options:\n");
/*@observer@*/ static const char *help_tail = N_(
"\n"
"source is asm source to be assembled.\n"
"\n"
"Sample invocation:\n"
" tasm /zi 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_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;
/* 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,
"obj",
"yasm.out");
}
}
cur_arch = yasm_arch_create(cur_arch_module, machine_name,
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;
}
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);
}
/* 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; i<NELEMS(version_msg); i++)
printf("%s\n", version_msg[i]);
return EXIT_SUCCESS;
case SPECIAL_SHOW_LICENSE:
for (i=0; i<NELEMS(license_msg); i++)
printf("%s\n", license_msg[i]);
return EXIT_SUCCESS;
}
/* Open error file if specified. */
if (error_filename) {
errfile = open_file(error_filename, "wt");
if (!errfile)
return EXIT_FAILURE;
}
/* If not already specified, default to bin as the object format. */
if (!cur_objfmt_module) {
if (!objfmt_keyword)
objfmt_keyword = yasm__xstrdup(DEFAULT_OBJFMT_MODULE);
cur_objfmt_module = yasm_load_objfmt(objfmt_keyword);
if (!cur_objfmt_module) {
print_error(_("%s: could not load default %s"), _("FATAL"),
_("object format"));
return EXIT_FAILURE;
}
}
/* TASM's architecture is x86 */
cur_arch_module = yasm_load_arch("x86");
if (!cur_arch_module) {
print_error(_("%s: could not load %s"), _("FATAL"),
_("architecture"));
return EXIT_FAILURE;
}
machine_name =
yasm__xstrdup(cur_arch_module->default_machine_keyword);
/* Check for arch help */
if (machine_name && strcmp(machine_name, "help") == 0) {
const yasm_arch_machine *m = cur_arch_module->machines;
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;
}
cur_parser_module = yasm_load_parser("tasm");
if (!cur_parser_module) {
print_error(_("%s: could not load %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;
}
/* If list file enabled, make sure we have a list format loaded. */
if (list_filename) {
/* use nasm as the list format. */
cur_listfmt_module = yasm_load_listfmt("nasm");
}
/* 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 (xref_filename)
yasm_xfree(xref_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
*/
static char ** const filenames[] = {
&in_filename, &obj_filename, &list_filename, &xref_filename, NULL
}, ** const * cur_filename = &filenames[0];
static int filename_handler(char *param) {
if (!*cur_filename) {
print_error(_("error: too many files on command line."));
return 1;
}
if (*param)
**cur_filename = yasm__xstrdup(param);
return 0;
}
int
not_an_option_handler(char *param) {
char *c, *d = param;
while ((c = strchr(d, ','))) {
*c = '\0';
if (filename_handler(d))
return 1;
d = c + 1;
cur_filename++;
}
filename_handler(d);
return 0;
}
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_segment_ordering_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param, int extra)
{
segment_ordering = extra;
return 0;
}
static int
opt_cross_reference_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param, int extra)
{
cross_reference = 1;
return 0;
}
static int
opt_floating_point_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param, int extra)
{
floating_point = extra;
return 0;
}
static int
opt_ignore(/*@unused@*/ char *cmd, /*@unused@*/ char *param, int extra)
{
return 0;
}
static int
opt_listing_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param, int extra)
{
if (param && param[0]) {
if (param[0] != 'a')
return 1;
expanded_listing = 1;
}
listing = 1;
return 0;
}
static int
opt_case_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param, int extra)
{
case_sensitivity = extra;
return 0;
}
static int
opt_valid_length_handler(/*@unused@*/ char *cmd, /*@unused@*/ char *param, int extra)
{
valid_length = atoi(param);
return 0;
}
static int
opt_warning_handler(char *cmd, /*@unused@*/ char *param, int extra)
{
/* is it disabling the warning instead of enabling? */
void (*action)(yasm_warn_class wclass) = NULL;
if (cmd[0] == '0') {
/* /w0, disable warnings */
yasm_warn_disable_all();
return 0;
}
if (cmd[0] == '1' || cmd[0] == '2') {
/* /w[12], enable warnings */
yasm_warn_enable(YASM_WARN_UNREC_CHAR);
yasm_warn_enable(YASM_WARN_ORPHAN_LABEL);
yasm_warn_enable(YASM_WARN_UNINIT_CONTENTS);
return 0;
}
/* detect no- prefix to disable the warning */
if (cmd[0] == '-') {
action = yasm_warn_disable;
} else if (cmd[0] == '+') {
action = yasm_warn_enable;
} else return 1;
/* skip past '+/-' */
cmd++;
if (cmd[0] == '\0')
/* just /w- or /w+, so definitely not valid */
return 1;
else if (strcmp(cmd, "error") == 0)
warning_error = (action == yasm_warn_enable);
else if (strcmp(cmd, "unrecognized-char") == 0)
action(YASM_WARN_UNREC_CHAR);
else if (strcmp(cmd, "orphan-labels") == 0)
action(YASM_WARN_ORPHAN_LABEL);
else if (strcmp(cmd, "uninit-contents") == 0)
action(YASM_WARN_UNINIT_CONTENTS);
else if (strcmp(cmd, "size-override") == 0)
action(YASM_WARN_SIZE_OVERRIDE);
else
return 1;
return 0;
}
static int
opt_preproc_option(/*@unused@*/ char *cmd, char *param, int extra)
{
constcharparam *cp;
cp = yasm_xmalloc(sizeof(constcharparam));
cp->param = param;
cp->id = extra;
STAILQ_INSERT_TAIL(&preproc_options, cp, link);
return 0;
}
static int
opt_exe_handler(char *cmd, /*@unused@*/ char *param, int extra)
{
objfmt_keyword = yasm__xstrdup("dosexe");
return 0;
}
static void
apply_preproc_builtins()
{
char *predef;
if (!objfmt_keyword)
objfmt_keyword = yasm__xstrdup(DEFAULT_OBJFMT_MODULE);
/* 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, "tasm: ");
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, "**%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 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, "**%s** %s(%lu) %s\n", _("Error"), filename, line, msg);
else
fprintf(errfile, "**%s** %s %s\n", _("Error"), filename, msg);
if (/* xref_fn && */ xref_msg) {
if (xref_line)
fprintf(errfile, "**%s** %s(%lu) %s\n", _("Error"), filename, xref_line, xref_msg);
else
fprintf(errfile, "**%s** %s %s\n", _("Error"), filename, xref_msg);
}
}
static void
print_yasm_warning(const char *filename, unsigned long line, const char *msg)
{
if (line)
fprintf(errfile, "*%s* %s(%lu) %s\n", _("Warning"), filename, line, msg);
else
fprintf(errfile, "*%s* %s %s\n", _("Warning"), filename, msg);
}