/* ----------------------------------------------------------------------- * * * Copyright 1996-2019 The NASM Authors - All Rights Reserved * See the file AUTHORS included with the NASM distribution for * the specific copyright holders. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following * conditions are met: * * * Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 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 COPYRIGHT HOLDERS AND * 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 COPYRIGHT OWNER OR * 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. * * ----------------------------------------------------------------------- */ /* * preproc.c macro preprocessor for the Netwide Assembler */ /* Typical flow of text through preproc * * pp_getline gets tokenized lines, either * * from a macro expansion * * or * { * read_line gets raw text from stdmacpos, or predef, or current input file * tokenize converts to tokens * } * * expand_mmac_params is used to expand %1 etc., unless a macro is being * defined or a false conditional is being processed * (%0, %1, %+1, %-1, %%foo * * do_directive checks for directives * * expand_smacro is used to expand single line macros * * expand_mmacro is used to expand multi-line macros * * detoken is used to convert the line back to text */ #include "compiler.h" #include "nctype.h" #include "nasm.h" #include "nasmlib.h" #include "error.h" #include "preproc.h" #include "hashtbl.h" #include "quote.h" #include "stdscan.h" #include "eval.h" #include "tokens.h" #include "tables.h" #include "listing.h" typedef struct SMacro SMacro; typedef struct MMacro MMacro; typedef struct MMacroInvocation MMacroInvocation; typedef struct Context Context; typedef struct Token Token; typedef struct Blocks Blocks; typedef struct Line Line; typedef struct Include Include; typedef struct Cond Cond; /* * Note on the storage of both SMacro and MMacros: the hash table * indexes them case-insensitively, and we then have to go through a * linked list of potential case aliases (and, for MMacros, parameter * ranges); this is to preserve the matching semantics of the earlier * code. If the number of case aliases for a specific macro is a * performance issue, you may want to reconsider your coding style. */ /* * Function call tp obtain the expansion of an smacro */ typedef Token *(*ExpandSMacro)(const SMacro *s, Token **params, unsigned int nparams); /* * Store the definition of a single-line macro. */ struct SMacro { SMacro *next; /* MUST BE FIRST - see free_smacro() */ char *name; Token *expansion; ExpandSMacro expand; intorptr expandpvt; bool *eval_param; unsigned int nparam; bool casesense; bool in_progress; bool alias; /* This is an alias macro */ }; /* * Store the definition of a multi-line macro. This is also used to * store the interiors of `%rep...%endrep' blocks, which are * effectively self-re-invoking multi-line macros which simply * don't have a name or bother to appear in the hash tables. %rep * blocks are signified by having a NULL `name' field. * * In a MMacro describing a `%rep' block, the `in_progress' field * isn't merely boolean, but gives the number of repeats left to * run. * * The `next' field is used for storing MMacros in hash tables; the * `next_active' field is for stacking them on istk entries. * * When a MMacro is being expanded, `params', `iline', `nparam', * `paramlen', `rotate' and `unique' are local to the invocation. */ struct MMacro { MMacro *next; MMacroInvocation *prev; /* previous invocation */ char *name; int nparam_min, nparam_max; bool casesense; bool plus; /* is the last parameter greedy? */ bool nolist; /* is this macro listing-inhibited? */ int64_t in_progress; /* is this macro currently being expanded? */ int32_t max_depth; /* maximum number of recursive expansions allowed */ Token *dlist; /* All defaults as one list */ Token **defaults; /* Parameter default pointers */ int ndefs; /* number of default parameters */ Line *expansion; MMacro *next_active; MMacro *rep_nest; /* used for nesting %rep */ Token **params; /* actual parameters */ Token *iline; /* invocation line */ unsigned int nparam, rotate; int *paramlen; uint64_t unique; int lineno; /* Current line number on expansion */ uint64_t condcnt; /* number of if blocks... */ const char *fname; /* File where defined */ int32_t xline; /* First line in macro */ }; /* Store the definition of a multi-line macro, as defined in a * previous recursive macro expansion. */ struct MMacroInvocation { MMacroInvocation *prev; /* previous invocation */ Token **params; /* actual parameters */ Token *iline; /* invocation line */ unsigned int nparam, rotate; int *paramlen; uint64_t unique; uint64_t condcnt; }; /* * The context stack is composed of a linked list of these. */ struct Context { Context *next; char *name; struct hash_table localmac; uint64_t number; unsigned int depth; }; /* * This is the internal form which we break input lines up into. * Typically stored in linked lists. * * Note that `type' serves a double meaning: TOK_SMAC_START_PARAMS is * not necessarily used as-is, but is also used to encode the number * and expansion type of substituted parameter. So in the definition * * %define a(x,=y) ( (x) & ~(y) ) * * the token representing `x' will have its type changed to * tok_smac_param(0) but the one representing `y' will be * tok_smac_param(1); see the accessor functions below. * * TOK_INTERNAL_STRING is a dirty hack: it's a single string token * which doesn't need quotes around it. Used in the pre-include * mechanism as an alternative to trying to find a sensible type of * quote to use on the filename we were passed. */ enum pp_token_type { TOK_NONE = 0, TOK_WHITESPACE, TOK_COMMENT, TOK_ID, TOK_PREPROC_ID, TOK_STRING, TOK_NUMBER, TOK_FLOAT, TOK_OTHER, TOK_INTERNAL_STRING, TOK_PREPROC_Q, TOK_PREPROC_QQ, TOK_PASTE, /* %+ */ TOK_INDIRECT, /* %[...] */ TOK_SMAC_START_PARAMS, /* MUST BE LAST IN THE LIST!!! */ TOK_MAX = INT_MAX /* Keep compiler from reducing the range */ }; static inline enum pp_token_type tok_smac_param(int param) { return TOK_SMAC_START_PARAMS + param; } static int smac_nparam(enum pp_token_type toktype) { return toktype - TOK_SMAC_START_PARAMS; } static bool is_smac_param(enum pp_token_type toktype) { return toktype >= TOK_SMAC_START_PARAMS; } #define PP_CONCAT_MASK(x) (1 << (x)) #define PP_CONCAT_MATCH(t, mask) (PP_CONCAT_MASK((t)->type) & mask) struct tokseq_match { int mask_head; int mask_tail; }; struct Token { Token *next; char *text; size_t len; enum pp_token_type type; }; /* * Multi-line macro definitions are stored as a linked list of * these, which is essentially a container to allow several linked * lists of Tokens. * * Note that in this module, linked lists are treated as stacks * wherever possible. For this reason, Lines are _pushed_ on to the * `expansion' field in MMacro structures, so that the linked list, * if walked, would give the macro lines in reverse order; this * means that we can walk the list when expanding a macro, and thus * push the lines on to the `expansion' field in _istk_ in reverse * order (so that when popped back off they are in the right * order). It may seem cockeyed, and it relies on my design having * an even number of steps in, but it works... * * Some of these structures, rather than being actual lines, are * markers delimiting the end of the expansion of a given macro. * This is for use in the cycle-tracking and %rep-handling code. * Such structures have `finishes' non-NULL, and `first' NULL. All * others have `finishes' NULL, but `first' may still be NULL if * the line is blank. */ struct Line { Line *next; MMacro *finishes; Token *first; }; /* * To handle an arbitrary level of file inclusion, we maintain a * stack (ie linked list) of these things. */ struct Include { Include *next; FILE *fp; Cond *conds; Line *expansion; const char *fname; MMacro *mstk; /* stack of active macros/reps */ int lineno, lineinc; bool nolist; }; /* * File real name hash, so we don't have to re-search the include * path for every pass (and potentially more than that if a file * is used more than once.) */ struct hash_table FileHash; /* * Conditional assembly: we maintain a separate stack of these for * each level of file inclusion. (The only reason we keep the * stacks separate is to ensure that a stray `%endif' in a file * included from within the true branch of a `%if' won't terminate * it and cause confusion: instead, rightly, it'll cause an error.) */ enum cond_state { /* * These states are for use just after %if or %elif: IF_TRUE * means the condition has evaluated to truth so we are * currently emitting, whereas IF_FALSE means we are not * currently emitting but will start doing so if a %else comes * up. In these states, all directives are admissible: %elif, * %else and %endif. (And of course %if.) */ COND_IF_TRUE, COND_IF_FALSE, /* * These states come up after a %else: ELSE_TRUE means we're * emitting, and ELSE_FALSE means we're not. In ELSE_* states, * any %elif or %else will cause an error. */ COND_ELSE_TRUE, COND_ELSE_FALSE, /* * These states mean that we're not emitting now, and also that * nothing until %endif will be emitted at all. COND_DONE is * used when we've had our moment of emission * and have now started seeing %elifs. COND_NEVER is used when * the condition construct in question is contained within a * non-emitting branch of a larger condition construct, * or if there is an error. */ COND_DONE, COND_NEVER }; struct Cond { Cond *next; enum cond_state state; }; #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE ) /* * These defines are used as the possible return values for do_directive */ #define NO_DIRECTIVE_FOUND 0 #define DIRECTIVE_FOUND 1 /* * Condition codes. Note that we use c_ prefix not C_ because C_ is * used in nasm.h for the "real" condition codes. At _this_ level, * we treat CXZ and ECXZ as condition codes, albeit non-invertible * ones, so we need a different enum... */ static const char * const conditions[] = { "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le", "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no", "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z" }; enum pp_conds { c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE, c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO, c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_RCXZ, c_S, c_Z, c_none = -1 }; static const enum pp_conds inverse_ccs[] = { c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE, c_A, c_AE, c_B, c_BE, c_C, c_E, c_G, c_GE, c_L, c_LE, c_O, c_P, c_S, c_Z, c_NO, c_NP, c_PO, c_PE, -1, c_NS, c_NZ }; /* * Directive names. */ /* If this is a an IF, ELIF, ELSE or ENDIF keyword */ static int is_condition(enum preproc_token arg) { return PP_IS_COND(arg) || (arg == PP_ELSE) || (arg == PP_ENDIF); } /* For TASM compatibility we need to be able to recognise TASM compatible * conditional compilation directives. Using the NASM pre-processor does * not work, so we look for them specifically from the following list and * then jam in the equivalent NASM directive into the input stream. */ enum { TM_ARG, TM_ELIF, TM_ELSE, TM_ENDIF, TM_IF, TM_IFDEF, TM_IFDIFI, TM_IFNDEF, TM_INCLUDE, TM_LOCAL }; static const char * const tasm_directives[] = { "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi", "ifndef", "include", "local" }; static int StackSize = 4; static const char *StackPointer = "ebp"; static int ArgOffset = 8; static int LocalOffset = 0; static Context *cstk; static Include *istk; static const struct strlist *ipath_list; static struct strlist *deplist; static uint64_t unique; /* unique identifier numbers */ static Line *predef = NULL; static bool do_predef; static enum preproc_mode pp_mode; /* * The current set of multi-line macros we have defined. */ static struct hash_table mmacros; /* * The current set of single-line macros we have defined. */ static struct hash_table smacros; /* * The multi-line macro we are currently defining, or the %rep * block we are currently reading, if any. */ static MMacro *defining; static uint64_t nested_mac_count; static uint64_t nested_rep_count; /* * The number of macro parameters to allocate space for at a time. */ #define PARAM_DELTA 16 /* * The standard macro set: defined in macros.c in a set of arrays. * This gives our position in any macro set, while we are processing it. * The stdmacset is an array of such macro sets. */ static macros_t *stdmacpos; static macros_t **stdmacnext; static macros_t *stdmacros[8]; static macros_t *extrastdmac; /* * Map of which %use packages have been loaded */ static bool *use_loaded; /* * Tokens are allocated in blocks to improve speed */ #define TOKEN_BLOCKSIZE 4096 static Token *freeTokens = NULL; struct Blocks { Blocks *next; void *chunk; }; static Blocks blocks = { NULL, NULL }; /* * Forward declarations. */ static void pp_add_stdmac(macros_t *macros); static Token *expand_mmac_params(Token * tline); static Token *expand_smacro(Token * tline); static Token *expand_id(Token * tline); static Context *get_ctx(const char *name, const char **namep); static Token *make_tok_num(int64_t val); static Token *make_tok_qstr(const char *str); static void pp_verror(errflags severity, const char *fmt, va_list ap); static vefunc real_verror; static void *new_Block(size_t size); static void delete_Blocks(void); static Token *new_Token(Token * next, enum pp_token_type type, const char *text, size_t txtlen); static Token *dup_Token(Token *next, const Token *src); static Token *delete_Token(Token * t); /* * Macros for safe checking of token pointers, avoid *(NULL) */ #define tok_type_(x,t) ((x) && (x)->type == (t)) #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v))) #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v)))) /* * In-place reverse a list of tokens. */ static Token *reverse_tokens(Token *t) { Token *prev = NULL; Token *next; while (t) { next = t->next; t->next = prev; prev = t; t = next; } return prev; } /* * Handle TASM specific directives, which do not contain a % in * front of them. We do it here because I could not find any other * place to do it for the moment, and it is a hack (ideally it would * be nice to be able to use the NASM pre-processor to do it). */ static char *check_tasm_directive(char *line) { int32_t i, j, k, m, len; char *p, *q, *oldline, oldchar; p = nasm_skip_spaces(line); /* Binary search for the directive name */ i = -1; j = ARRAY_SIZE(tasm_directives); q = nasm_skip_word(p); len = q - p; if (len) { oldchar = p[len]; p[len] = 0; while (j - i > 1) { k = (j + i) / 2; m = nasm_stricmp(p, tasm_directives[k]); if (m == 0) { /* We have found a directive, so jam a % in front of it * so that NASM will then recognise it as one if it's own. */ p[len] = oldchar; len = strlen(p); oldline = line; line = nasm_malloc(len + 2); line[0] = '%'; if (k == TM_IFDIFI) { /* * NASM does not recognise IFDIFI, so we convert * it to %if 0. This is not used in NASM * compatible code, but does need to parse for the * TASM macro package. */ strcpy(line + 1, "if 0"); } else { memcpy(line + 1, p, len + 1); } nasm_free(oldline); return line; } else if (m < 0) { j = k; } else i = k; } p[len] = oldchar; } return line; } /* * The pre-preprocessing stage... This function translates line * number indications as they emerge from GNU cpp (`# lineno "file" * flags') into NASM preprocessor line number indications (`%line * lineno file'). */ static char *prepreproc(char *line) { int lineno, fnlen; char *fname, *oldline; if (line[0] == '#' && line[1] == ' ') { oldline = line; fname = oldline + 2; lineno = atoi(fname); fname += strspn(fname, "0123456789 "); if (*fname == '"') fname++; fnlen = strcspn(fname, "\""); line = nasm_malloc(20 + fnlen); snprintf(line, 20 + fnlen, "%%line %d %.*s", lineno, fnlen, fname); nasm_free(oldline); } if (tasm_compatible_mode) return check_tasm_directive(line); return line; } /* * Free a linked list of tokens. */ static void free_tlist(Token * list) { while (list) list = delete_Token(list); } /* * Free a linked list of lines. */ static void free_llist(Line * list) { Line *l, *tmp; list_for_each_safe(l, tmp, list) { free_tlist(l->first); nasm_free(l); } } /* * Free an array of linked lists of tokens */ static void free_tlist_array(Token **array, size_t nlists) { Token **listp = array; while (nlists--) free_tlist(*listp++); nasm_free(array); } /* * Duplicate a linked list of tokens. */ static Token *dup_tlist(const Token *list, Token ***tailp) { Token *newlist = NULL; Token **tailpp = &newlist; const Token *t; list_for_each(t, list) { Token *nt; *tailpp = nt = dup_Token(NULL, t); tailpp = &nt->next; } if (tailp) *tailp = tailpp; return newlist; } /* * Duplicate a linked list of tokens in reverse order */ static Token *dup_tlist_reverse(const Token *list, Token *tail) { const Token *t; list_for_each(t, list) tail = dup_Token(tail, t); return tail; } /* * Free an MMacro */ static void free_mmacro(MMacro * m) { nasm_free(m->name); free_tlist(m->dlist); nasm_free(m->defaults); free_llist(m->expansion); nasm_free(m); } /* * Clear or free an SMacro */ static void free_smacro_members(SMacro *s) { nasm_free(s->name); free_tlist(s->expansion); nasm_free(s->eval_param); } static void clear_smacro(SMacro *s) { free_smacro_members(s); /* Wipe everything except the next pointer */ memset(&s->next + 1, 0, sizeof *s - sizeof s->next); } /* * Free an SMacro */ static void free_smacro(SMacro *s) { free_smacro_members(s); nasm_free(s); } /* * Free all currently defined macros, and free the hash tables */ static void free_smacro_table(struct hash_table *smt) { struct hash_iterator it; const struct hash_node *np; hash_for_each(smt, it, np) { SMacro *tmp; SMacro *s = np->data; nasm_free((void *)np->key); list_for_each_safe(s, tmp, s) free_smacro(s); } hash_free(smt); } static void free_mmacro_table(struct hash_table *mmt) { struct hash_iterator it; const struct hash_node *np; hash_for_each(mmt, it, np) { MMacro *tmp; MMacro *m = np->data; nasm_free((void *)np->key); list_for_each_safe(m, tmp, m) free_mmacro(m); } hash_free(mmt); } static void free_macros(void) { free_smacro_table(&smacros); free_mmacro_table(&mmacros); } /* * Initialize the hash tables */ static void init_macros(void) { } /* * Pop the context stack. */ static void ctx_pop(void) { Context *c = cstk; cstk = cstk->next; free_smacro_table(&c->localmac); nasm_free(c->name); nasm_free(c); } /* * Search for a key in the hash index; adding it if necessary * (in which case we initialize the data pointer to NULL.) */ static void ** hash_findi_add(struct hash_table *hash, const char *str) { struct hash_insert hi; void **r; char *strx; size_t l = strlen(str) + 1; r = hash_findib(hash, str, l, &hi); if (r) return r; strx = nasm_malloc(l); /* Use a more efficient allocator here? */ memcpy(strx, str, l); return hash_add(&hi, strx, NULL); } /* * Like hash_findi, but returns the data element rather than a pointer * to it. Used only when not adding a new element, hence no third * argument. */ static void * hash_findix(struct hash_table *hash, const char *str) { void **p; p = hash_findi(hash, str, NULL); return p ? *p : NULL; } /* * read line from standart macros set, * if there no more left -- return NULL */ static char *line_from_stdmac(void) { unsigned char c; const unsigned char *p = stdmacpos; char *line, *q; size_t len = 0; if (!stdmacpos) return NULL; /* * 32-126 is ASCII, 127 is end of line, 128-31 are directives * (allowed to wrap around) corresponding to PP_* tokens 0-159. */ while ((c = *p++) != 127) { uint8_t ndir = c - 128; if (ndir < 256-96) len += pp_directives_len[ndir] + 1; else len++; } line = nasm_malloc(len + 1); q = line; while ((c = *stdmacpos++) != 127) { uint8_t ndir = c - 128; if (ndir < 256-96) { memcpy(q, pp_directives[ndir], pp_directives_len[ndir]); q += pp_directives_len[ndir]; *q++ = ' '; } else { *q++ = c; } } stdmacpos = p; *q = '\0'; if (*stdmacpos == 127) { /* This was the last of this particular macro set */ stdmacpos = NULL; if (*stdmacnext) { stdmacpos = *stdmacnext++; } else if (do_predef) { Line *pd, *l; /* * Nasty hack: here we push the contents of * `predef' on to the top-level expansion stack, * since this is the most convenient way to * implement the pre-include and pre-define * features. */ list_for_each(pd, predef) { nasm_new(l); l->next = istk->expansion; l->first = dup_tlist(pd->first, NULL); l->finishes = NULL; istk->expansion = l; } do_predef = false; } } return line; } /* * Read a line from a file. Return NULL on end of file. */ static char *line_from_file(void) { int c; unsigned int size, next; const unsigned int delta = 512; const unsigned int pad = 8; unsigned int nr_cont = 0; bool cont = false; char *buffer, *p; int32_t lineno; size = delta; p = buffer = nasm_malloc(size); do { c = fgetc(istk->fp); switch (c) { case EOF: if (p == buffer) { nasm_free(buffer); return NULL; } c = 0; break; case '\r': next = fgetc(istk->fp); if (next != '\n') ungetc(next, istk->fp); if (cont) { cont = false; continue; } c = 0; break; case '\n': if (cont) { cont = false; continue; } c = 0; break; case 032: /* ^Z = legacy MS-DOS end of file mark */ c = 0; break; case '\\': next = fgetc(istk->fp); ungetc(next, istk->fp); if (next == '\r' || next == '\n') { cont = true; nr_cont++; continue; } break; } if (p >= (buffer + size - pad)) { buffer = nasm_realloc(buffer, size + delta); p = buffer + size - pad; size += delta; } *p++ = c; } while (c); lineno = src_get_linnum() + istk->lineinc + (nr_cont * istk->lineinc); src_set_linnum(lineno); return buffer; } /* * Common read routine regardless of source */ static char *read_line(void) { char *line; if (istk->fp) line = line_from_file(); else line = line_from_stdmac(); if (!line) return NULL; if (!istk->nolist) lfmt->line(LIST_READ, src_get_linnum(), line); return line; } /* * Tokenize a line of text. This is a very simple process since we * don't need to parse the value out of e.g. numeric tokens: we * simply split one string into many. */ static Token *tokenize(char *line) { char c; enum pp_token_type type; Token *list = NULL; Token *t, **tail = &list; while (*line) { char *p = line; char *ep = NULL; /* End of token, for trimming the end */ if (*p == '%') { p++; if (*p == '+' && !nasm_isdigit(p[1])) { p++; type = TOK_PASTE; } else if (nasm_isdigit(*p) || ((*p == '-' || *p == '+') && nasm_isdigit(p[1]))) { do { p++; } while (nasm_isdigit(*p)); type = TOK_PREPROC_ID; } else if (*p == '{') { p++; while (*p) { if (*p == '}') break; p[-1] = *p; p++; } if (*p != '}') nasm_warn(WARN_OTHER, "unterminated %%{ construct"); ep = &p[-1]; if (*p) p++; type = TOK_PREPROC_ID; } else if (*p == '[') { int lvl = 1; line += 2; /* Skip the leading %[ */ p++; while (lvl && (c = *p++)) { switch (c) { case ']': lvl--; break; case '%': if (*p == '[') lvl++; break; case '\'': case '\"': case '`': p = nasm_skip_string(p - 1); if (*p) p++; break; default: break; } } p--; ep = p; if (*p) p++; if (lvl) nasm_nonfatalf(ERR_PASS1, "unterminated %%[ construct"); type = TOK_INDIRECT; } else if (*p == '?') { type = TOK_PREPROC_Q; /* %? */ p++; if (*p == '?') { type = TOK_PREPROC_QQ; /* %?? */ p++; } } else if (*p == '!') { type = TOK_PREPROC_ID; p++; if (nasm_isidchar(*p)) { do { p++; } while (nasm_isidchar(*p)); } else if (nasm_isquote(*p)) { p = nasm_skip_string(p); if (*p) p++; else nasm_nonfatalf(ERR_PASS1, "unterminated %%! string"); } else { /* %! without string or identifier */ type = TOK_OTHER; /* Legacy behavior... */ } } else if (nasm_isidchar(*p) || ((*p == '!' || *p == '%' || *p == '$') && nasm_isidchar(p[1]))) { do { p++; } while (nasm_isidchar(*p)); type = TOK_PREPROC_ID; } else { type = TOK_OTHER; if (*p == '%') p++; } } else if (nasm_isidstart(*p) || (*p == '$' && nasm_isidstart(p[1]))) { type = TOK_ID; p++; while (*p && nasm_isidchar(*p)) p++; } else if (nasm_isquote(*p)) { /* * A string token. */ type = TOK_STRING; p = nasm_skip_string(p); if (*p) { p++; } else { nasm_warn(WARN_OTHER, "unterminated string"); /* Handling unterminated strings by UNV */ /* type = -1; */ } } else if (p[0] == '$' && p[1] == '$') { type = TOK_OTHER; /* TOKEN_BASE */ p += 2; } else if (nasm_isnumstart(*p)) { bool is_hex = false; bool is_float = false; bool has_e = false; char c, *r; /* * A numeric token. */ if (*p == '$') { p++; is_hex = true; } for (;;) { c = *p++; if (!is_hex && (c == 'e' || c == 'E')) { has_e = true; if (*p == '+' || *p == '-') { /* * e can only be followed by +/- if it is either a * prefixed hex number or a floating-point number */ p++; is_float = true; } } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') { is_hex = true; } else if (c == 'P' || c == 'p') { is_float = true; if (*p == '+' || *p == '-') p++; } else if (nasm_isnumchar(c)) ; /* just advance */ else if (c == '.') { /* * we need to deal with consequences of the legacy * parser, like "1.nolist" being two tokens * (TOK_NUMBER, TOK_ID) here; at least give it * a shot for now. In the future, we probably need * a flex-based scanner with proper pattern matching * to do it as well as it can be done. Nothing in * the world is going to help the person who wants * 0x123.p16 interpreted as two tokens, though. */ r = p; while (*r == '_') r++; if (nasm_isdigit(*r) || (is_hex && nasm_isxdigit(*r)) || (!is_hex && (*r == 'e' || *r == 'E')) || (*r == 'p' || *r == 'P')) { p = r; is_float = true; } else break; /* Terminate the token */ } else break; } p--; /* Point to first character beyond number */ if (p == line+1 && *line == '$') { type = TOK_OTHER; /* TOKEN_HERE */ } else { if (has_e && !is_hex) { /* 1e13 is floating-point, but 1e13h is not */ is_float = true; } type = is_float ? TOK_FLOAT : TOK_NUMBER; } } else if (nasm_isspace(*p)) { type = TOK_WHITESPACE; p = nasm_skip_spaces(p); /* * Whitespace just before end-of-line is discarded by * pretending it's a comment; whitespace just before a * comment gets lumped into the comment. */ if (!*p || *p == ';') { type = TOK_COMMENT; while (*p) p++; } } else if (*p == ';') { type = TOK_COMMENT; while (*p) p++; } else { /* * Anything else is an operator of some kind. We check * for all the double-character operators (>>, <<, //, * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything * else is a single-character operator. */ type = TOK_OTHER; if ((p[0] == '>' && p[1] == '>') || (p[0] == '<' && p[1] == '<') || (p[0] == '/' && p[1] == '/') || (p[0] == '<' && p[1] == '=') || (p[0] == '>' && p[1] == '=') || (p[0] == '=' && p[1] == '=') || (p[0] == '!' && p[1] == '=') || (p[0] == '<' && p[1] == '>') || (p[0] == '&' && p[1] == '&') || (p[0] == '|' && p[1] == '|') || (p[0] == '^' && p[1] == '^')) { p++; } p++; } /* Handling unterminated string by UNV */ /*if (type == -1) { *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1); t->text[p-line] = *line; tail = &t->next; } else */ if (type != TOK_COMMENT) { if (!ep) ep = p; *tail = t = new_Token(NULL, type, line, ep - line); tail = &t->next; } line = p; } return list; } /* * this function allocates a new managed block of memory and * returns a pointer to the block. The managed blocks are * deleted only all at once by the delete_Blocks function. */ static void *new_Block(size_t size) { Blocks *b = &blocks; /* first, get to the end of the linked list */ while (b->next) b = b->next; /* now allocate the requested chunk */ b->chunk = nasm_malloc(size); /* now allocate a new block for the next request */ b->next = nasm_zalloc(sizeof(Blocks)); return b->chunk; } /* * this function deletes all managed blocks of memory */ static void delete_Blocks(void) { Blocks *a, *b = &blocks; /* * keep in mind that the first block, pointed to by blocks * is a static and not dynamically allocated, so we don't * free it. */ while (b) { if (b->chunk) nasm_free(b->chunk); a = b; b = b->next; if (a != &blocks) nasm_free(a); } memset(&blocks, 0, sizeof(blocks)); } /* * this function creates a new Token and passes a pointer to it * back to the caller. It sets the type, text, and next pointer elements. */ static Token *new_Token(Token * next, enum pp_token_type type, const char *text, size_t txtlen) { Token *t; int i; if (!freeTokens) { freeTokens = (Token *) new_Block(TOKEN_BLOCKSIZE * sizeof(Token)); for (i = 0; i < TOKEN_BLOCKSIZE - 1; i++) freeTokens[i].next = &freeTokens[i + 1]; freeTokens[i].next = NULL; } t = freeTokens; freeTokens = t->next; t->next = next; t->type = type; if (type == TOK_WHITESPACE || !text) { t->len = 0; t->text = NULL; } else { if (txtlen == 0 && text[0]) txtlen = strlen(text); t->len = txtlen; t->text = nasm_malloc(txtlen+1); memcpy(t->text, text, txtlen); t->text[txtlen] = '\0'; } return t; } static Token *dup_Token(Token *next, const Token *src) { return new_Token(next, src->type, src->text, src->len); } static Token *delete_Token(Token * t) { Token *next = t->next; nasm_free(t->text); t->next = freeTokens; freeTokens = t; return next; } /* * Convert a line of tokens back into text. * If expand_locals is not zero, identifiers of the form "%$*xxx" * will be transformed into ..@ctxnum.xxx */ static char *detoken(Token * tlist, bool expand_locals) { Token *t; char *line, *p; int len = 0; list_for_each(t, tlist) { if (t->type == TOK_PREPROC_ID && t->text && t->text[0] == '%' && t->text[1] == '!') { char *v; char *q = t->text; v = t->text + 2; if (nasm_isquote(*v)) nasm_unquote_cstr(v, NULL); if (v) { char *p = getenv(v); if (!p) { /*! *!environment [on] nonexistent environment variable *! warns if a nonexistent environment variable *! is accessed using the \c{%!} preprocessor *! construct (see \k{getenv}.) Such environment *! variables are treated as empty (with this *! warning issued) starting in NASM 2.15; *! earlier versions of NASM would treat this as *! an error. */ nasm_warn(WARN_ENVIRONMENT, "nonexistent environment variable `%s'", v); p = ""; } t->text = nasm_strdup(p); t->len = nasm_last_string_len(); nasm_free(q); } } /* Expand local macros here and not during preprocessing */ if (expand_locals && t->type == TOK_PREPROC_ID && t->text && t->text[0] == '%' && t->text[1] == '$') { const char *q; char *p; Context *ctx = get_ctx(t->text, &q); if (ctx) { p = nasm_asprintf("..@%"PRIu64".%s", ctx->number, q); t->len = nasm_last_string_len(); nasm_free(t->text); t->text = p; } } if (t->text) { if (debug_level(2)) { unsigned long t_len = t->len; unsigned long s_len = strlen(t->text); if (t_len != s_len) { nasm_panic("assertion failed: token \"%s\" type %u len %lu has t->len %lu\n", t->text, t->type, s_len, t_len); t->len = s_len; } } len += t->len; } else if (t->type == TOK_WHITESPACE) { len++; } } p = line = nasm_malloc(len + 1); list_for_each(t, tlist) { if (t->text) { memcpy(p, t->text, t->len); p += t->len; } else if (t->type == TOK_WHITESPACE) { *p++ = ' '; } } *p = '\0'; return line; } /* * A scanner, suitable for use by the expression evaluator, which * operates on a line of Tokens. Expects a pointer to a pointer to * the first token in the line to be passed in as its private_data * field. * * FIX: This really needs to be unified with stdscan. */ struct ppscan { Token *tptr; int ntokens; }; static int ppscan(void *private_data, struct tokenval *tokval) { struct ppscan *pps = private_data; Token *tline; char ourcopy[MAX_KEYWORD+1], *p, *r, *s; do { if (pps->ntokens && (tline = pps->tptr)) { pps->ntokens--; pps->tptr = tline->next; } else { pps->tptr = NULL; pps->ntokens = 0; return tokval->t_type = TOKEN_EOS; } } while (tline->type == TOK_WHITESPACE || tline->type == TOK_COMMENT); tokval->t_charptr = tline->text; if (tline->text[0] == '$' && !tline->text[1]) return tokval->t_type = TOKEN_HERE; if (tline->text[0] == '$' && tline->text[1] == '$' && !tline->text[2]) return tokval->t_type = TOKEN_BASE; if (tline->type == TOK_ID) { p = tokval->t_charptr = tline->text; if (p[0] == '$') { tokval->t_charptr++; return tokval->t_type = TOKEN_ID; } for (r = p, s = ourcopy; *r; r++) { if (r >= p+MAX_KEYWORD) return tokval->t_type = TOKEN_ID; /* Not a keyword */ *s++ = nasm_tolower(*r); } *s = '\0'; /* right, so we have an identifier sitting in temp storage. now, * is it actually a register or instruction name, or what? */ return nasm_token_hash(ourcopy, tokval); } if (tline->type == TOK_NUMBER) { bool rn_error; tokval->t_integer = readnum(tline->text, &rn_error); tokval->t_charptr = tline->text; if (rn_error) return tokval->t_type = TOKEN_ERRNUM; else return tokval->t_type = TOKEN_NUM; } if (tline->type == TOK_FLOAT) { return tokval->t_type = TOKEN_FLOAT; } if (tline->type == TOK_STRING) { char bq, *ep; bq = tline->text[0]; tokval->t_charptr = tline->text; tokval->t_inttwo = nasm_unquote(tline->text, &ep); if (ep[0] != bq || ep[1] != '\0') return tokval->t_type = TOKEN_ERRSTR; else return tokval->t_type = TOKEN_STR; } if (tline->type == TOK_OTHER) { if (!strcmp(tline->text, "<<")) return tokval->t_type = TOKEN_SHL; if (!strcmp(tline->text, ">>")) return tokval->t_type = TOKEN_SHR; if (!strcmp(tline->text, "//")) return tokval->t_type = TOKEN_SDIV; if (!strcmp(tline->text, "%%")) return tokval->t_type = TOKEN_SMOD; if (!strcmp(tline->text, "==")) return tokval->t_type = TOKEN_EQ; if (!strcmp(tline->text, "<>")) return tokval->t_type = TOKEN_NE; if (!strcmp(tline->text, "!=")) return tokval->t_type = TOKEN_NE; if (!strcmp(tline->text, "<=")) return tokval->t_type = TOKEN_LE; if (!strcmp(tline->text, ">=")) return tokval->t_type = TOKEN_GE; if (!strcmp(tline->text, "&&")) return tokval->t_type = TOKEN_DBL_AND; if (!strcmp(tline->text, "^^")) return tokval->t_type = TOKEN_DBL_XOR; if (!strcmp(tline->text, "||")) return tokval->t_type = TOKEN_DBL_OR; } /* * We have no other options: just return the first character of * the token text. */ return tokval->t_type = tline->text[0]; } /* * Compare a string to the name of an existing macro; this is a * simple wrapper which calls either strcmp or nasm_stricmp * depending on the value of the `casesense' parameter. */ static int mstrcmp(const char *p, const char *q, bool casesense) { return casesense ? strcmp(p, q) : nasm_stricmp(p, q); } /* * Compare a string to the name of an existing macro; this is a * simple wrapper which calls either strcmp or nasm_stricmp * depending on the value of the `casesense' parameter. */ static int mmemcmp(const char *p, const char *q, size_t l, bool casesense) { return casesense ? memcmp(p, q, l) : nasm_memicmp(p, q, l); } /* * Return the Context structure associated with a %$ token. Return * NULL, having _already_ reported an error condition, if the * context stack isn't deep enough for the supplied number of $ * signs. * * If "namep" is non-NULL, set it to the pointer to the macro name * tail, i.e. the part beyond %$... */ static Context *get_ctx(const char *name, const char **namep) { Context *ctx; int i; if (namep) *namep = name; if (!name || name[0] != '%' || name[1] != '$') return NULL; if (!cstk) { nasm_nonfatal("`%s': context stack is empty", name); return NULL; } name += 2; ctx = cstk; i = 0; while (ctx && *name == '$') { name++; i++; ctx = ctx->next; } if (!ctx) { nasm_nonfatal("`%s': context stack is only" " %d level%s deep", name, i, (i == 1 ? "" : "s")); return NULL; } if (namep) *namep = name; return ctx; } /* * Open an include file. This routine must always return a valid * file pointer if it returns - it's responsible for throwing an * ERR_FATAL and bombing out completely if not. It should also try * the include path one by one until it finds the file or reaches * the end of the path. * * Note: for INC_PROBE the function returns NULL at all times; * instead look for the */ enum incopen_mode { INC_NEEDED, /* File must exist */ INC_OPTIONAL, /* Missing is OK */ INC_PROBE /* Only an existence probe */ }; /* This is conducts a full pathname search */ static FILE *inc_fopen_search(const char *file, char **slpath, enum incopen_mode omode, enum file_flags fmode) { const struct strlist_entry *ip = strlist_head(ipath_list); FILE *fp; const char *prefix = ""; char *sp; bool found; while (1) { sp = nasm_catfile(prefix, file); if (omode == INC_PROBE) { fp = NULL; found = nasm_file_exists(sp); } else { fp = nasm_open_read(sp, fmode); found = (fp != NULL); } if (found) { *slpath = sp; return fp; } nasm_free(sp); if (!ip) { *slpath = NULL; return NULL; } prefix = ip->str; ip = ip->next; } } /* * Open a file, or test for the presence of one (depending on omode), * considering the include path. */ static FILE *inc_fopen(const char *file, struct strlist *dhead, const char **found_path, enum incopen_mode omode, enum file_flags fmode) { struct hash_insert hi; void **hp; char *path; FILE *fp = NULL; hp = hash_find(&FileHash, file, &hi); if (hp) { path = *hp; if (path || omode != INC_NEEDED) { strlist_add(dhead, path ? path : file); } } else { /* Need to do the actual path search */ fp = inc_fopen_search(file, &path, omode, fmode); /* Positive or negative result */ hash_add(&hi, nasm_strdup(file), path); /* * Add file to dependency path. */ if (path || omode != INC_NEEDED) strlist_add(dhead, file); } if (!path) { if (omode == INC_NEEDED) nasm_fatal("unable to open include file `%s'", file); } else { if (!fp && omode != INC_PROBE) fp = nasm_open_read(path, fmode); } if (found_path) *found_path = path; return fp; } /* * Opens an include or input file. Public version, for use by modules * that get a file:lineno pair and need to look at the file again * (e.g. the CodeView debug backend). Returns NULL on failure. */ FILE *pp_input_fopen(const char *filename, enum file_flags mode) { return inc_fopen(filename, NULL, NULL, INC_OPTIONAL, mode); } /* * Determine if we should warn on defining a single-line macro of * name `name', with `nparam' parameters. If nparam is 0 or -1, will * return true if _any_ single-line macro of that name is defined. * Otherwise, will return true if a single-line macro with either * `nparam' or no parameters is defined. * * If a macro with precisely the right number of parameters is * defined, or nparam is -1, the address of the definition structure * will be returned in `defn'; otherwise NULL will be returned. If `defn' * is NULL, no action will be taken regarding its contents, and no * error will occur. * * Note that this is also called with nparam zero to resolve * `ifdef'. * * If you already know which context macro belongs to, you can pass * the context pointer as first parameter; if you won't but name begins * with %$ the context will be automatically computed. If all_contexts * is true, macro will be searched in outer contexts as well. */ static bool smacro_defined(Context * ctx, const char *name, int nparam, SMacro ** defn, bool nocase) { struct hash_table *smtbl; SMacro *m; if (ctx) { smtbl = &ctx->localmac; } else if (name[0] == '%' && name[1] == '$') { if (cstk) ctx = get_ctx(name, &name); if (!ctx) return false; /* got to return _something_ */ smtbl = &ctx->localmac; } else { smtbl = &smacros; } m = (SMacro *) hash_findix(smtbl, name); while (m) { if (!mstrcmp(m->name, name, m->casesense && nocase) && (nparam <= 0 || m->nparam == 0 || nparam == (int) m->nparam)) { if (defn) { if (nparam == (int) m->nparam || nparam == -1) *defn = m; else *defn = NULL; } return true; } m = m->next; } return false; } /* param should be a natural number [0; INT_MAX] */ static int read_param_count(const char *str) { int result; bool err; result = readnum(str, &err); if (result < 0 || result > INT_MAX) { result = 0; nasm_nonfatal("parameter count `%s' is out of bounds [%d; %d]", str, 0, INT_MAX); } else if (err) nasm_nonfatal("unable to parse parameter count `%s'", str); return result; } /* * Count and mark off the parameters in a multi-line macro call. * This is called both from within the multi-line macro expansion * code, and also to mark off the default parameters when provided * in a %macro definition line. */ static void count_mmac_params(Token * t, int *nparam, Token *** params) { int paramsize, brace; *nparam = paramsize = 0; *params = NULL; while (t) { /* +1: we need space for the final NULL */ if (*nparam+1 >= paramsize) { paramsize += PARAM_DELTA; *params = nasm_realloc(*params, sizeof(**params) * paramsize); } skip_white_(t); brace = 0; if (tok_is_(t, "{")) brace++; (*params)[(*nparam)++] = t; if (brace) { while (brace && (t = t->next) != NULL) { if (tok_is_(t, "{")) brace++; else if (tok_is_(t, "}")) brace--; } if (t) { /* * Now we've found the closing brace, look further * for the comma. */ t = t->next; skip_white_(t); if (tok_isnt_(t, ",")) { nasm_nonfatal("braces do not enclose all of macro parameter"); while (tok_isnt_(t, ",")) t = t->next; } } } else { while (tok_isnt_(t, ",")) t = t->next; } if (t) { /* got a comma/brace */ t = t->next; /* eat the comma */ } } } /* * Determine whether one of the various `if' conditions is true or * not. * * We must free the tline we get passed. */ static enum cond_state if_condition(Token * tline, enum preproc_token ct) { bool j; Token *t, *tt, *origline; struct ppscan pps; struct tokenval tokval; expr *evalresult; enum pp_token_type needtype; char *p; const char *dname = pp_directives[ct]; bool casesense = true; origline = tline; switch (PP_COND(ct)) { case PP_IFCTX: j = false; /* have we matched yet? */ while (true) { skip_white_(tline); if (!tline) break; if (tline->type != TOK_ID) { nasm_nonfatal("`%s' expects context identifiers", dname); goto fail; } if (cstk && cstk->name && !nasm_stricmp(tline->text, cstk->name)) j = true; tline = tline->next; } break; case PP_IFDEF: j = false; /* have we matched yet? */ while (tline) { skip_white_(tline); if (!tline || (tline->type != TOK_ID && (tline->type != TOK_PREPROC_ID || tline->text[1] != '$'))) { nasm_nonfatal("`%s' expects macro identifiers", dname); goto fail; } if (smacro_defined(NULL, tline->text, 0, NULL, true)) j = true; tline = tline->next; } break; case PP_IFENV: tline = expand_smacro(tline); j = false; /* have we matched yet? */ while (tline) { skip_white_(tline); if (!tline || (tline->type != TOK_ID && tline->type != TOK_STRING && (tline->type != TOK_PREPROC_ID || tline->text[1] != '!'))) { nasm_nonfatal("`%s' expects environment variable names", dname); goto fail; } p = tline->text; if (tline->type == TOK_PREPROC_ID) p += 2; /* Skip leading %! */ if (nasm_isquote(*p)) nasm_unquote_cstr(p, NULL); if (getenv(p)) j = true; tline = tline->next; } break; case PP_IFIDNI: casesense = false; /* fall through */ case PP_IFIDN: tline = expand_smacro(tline); t = tt = tline; while (tok_isnt_(tt, ",")) tt = tt->next; if (!tt) { nasm_nonfatal("`%s' expects two comma-separated arguments", dname); goto fail; } tt = tt->next; j = true; /* assume equality unless proved not */ while ((t->type != TOK_OTHER || strcmp(t->text, ",")) && tt) { if (tt->type == TOK_OTHER && !strcmp(tt->text, ",")) { nasm_nonfatal("`%s': more than one comma on line", dname); goto fail; } if (t->type == TOK_WHITESPACE) { t = t->next; continue; } if (tt->type == TOK_WHITESPACE) { tt = tt->next; continue; } if (tt->type != t->type) { j = false; /* found mismatching tokens */ break; } /* When comparing strings, need to unquote them first */ if (t->type == TOK_STRING) { size_t l1 = nasm_unquote(t->text, NULL); size_t l2 = nasm_unquote(tt->text, NULL); if (l1 != l2) { j = false; break; } if (mmemcmp(t->text, tt->text, l1, casesense)) { j = false; break; } } else if (mstrcmp(tt->text, t->text, casesense) != 0) { j = false; /* found mismatching tokens */ break; } t = t->next; tt = tt->next; } if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt) j = false; /* trailing gunk on one end or other */ break; case PP_IFMACRO: { bool found = false; MMacro searching, *mmac; skip_white_(tline); tline = expand_id(tline); if (!tok_type_(tline, TOK_ID)) { nasm_nonfatal("`%s' expects a macro name", dname); goto fail; } searching.name = nasm_strdup(tline->text); searching.casesense = true; searching.plus = false; searching.nolist = false; searching.in_progress = 0; searching.max_depth = 0; searching.rep_nest = NULL; searching.nparam_min = 0; searching.nparam_max = INT_MAX; tline = expand_smacro(tline->next); skip_white_(tline); if (!tline) { } else if (!tok_type_(tline, TOK_NUMBER)) { nasm_nonfatal("`%s' expects a parameter count or nothing", dname); } else { searching.nparam_min = searching.nparam_max = read_param_count(tline->text); } if (tline && tok_is_(tline->next, "-")) { tline = tline->next->next; if (tok_is_(tline, "*")) searching.nparam_max = INT_MAX; else if (!tok_type_(tline, TOK_NUMBER)) nasm_nonfatal("`%s' expects a parameter count after `-'", dname); else { searching.nparam_max = read_param_count(tline->text); if (searching.nparam_min > searching.nparam_max) { nasm_nonfatal("minimum parameter count exceeds maximum"); searching.nparam_max = searching.nparam_min; } } } if (tline && tok_is_(tline->next, "+")) { tline = tline->next; searching.plus = true; } mmac = (MMacro *) hash_findix(&mmacros, searching.name); while (mmac) { if (!strcmp(mmac->name, searching.name) && (mmac->nparam_min <= searching.nparam_max || searching.plus) && (searching.nparam_min <= mmac->nparam_max || mmac->plus)) { found = true; break; } mmac = mmac->next; } if (tline && tline->next) nasm_warn(WARN_OTHER, "trailing garbage after %%ifmacro ignored"); nasm_free(searching.name); j = found; break; } case PP_IFID: needtype = TOK_ID; goto iftype; case PP_IFNUM: needtype = TOK_NUMBER; goto iftype; case PP_IFSTR: needtype = TOK_STRING; goto iftype; iftype: t = tline = expand_smacro(tline); while (tok_type_(t, TOK_WHITESPACE) || (needtype == TOK_NUMBER && tok_type_(t, TOK_OTHER) && (t->text[0] == '-' || t->text[0] == '+') && !t->text[1])) t = t->next; j = tok_type_(t, needtype); break; case PP_IFTOKEN: t = tline = expand_smacro(tline); while (tok_type_(t, TOK_WHITESPACE)) t = t->next; j = false; if (t) { t = t->next; /* Skip the actual token */ while (tok_type_(t, TOK_WHITESPACE)) t = t->next; j = !t; /* Should be nothing left */ } break; case PP_IFEMPTY: t = tline = expand_smacro(tline); while (tok_type_(t, TOK_WHITESPACE)) t = t->next; j = !t; /* Should be empty */ break; case PP_IF: pps.tptr = tline = expand_smacro(tline); pps.ntokens = -1; tokval.t_type = TOKEN_INVALID; evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); if (!evalresult) return -1; if (tokval.t_type) nasm_warn(WARN_OTHER, "trailing garbage after expression ignored"); if (!is_simple(evalresult)) { nasm_nonfatal("non-constant value given to `%s'", dname); goto fail; } j = reloc_value(evalresult) != 0; break; default: nasm_nonfatal("unknown preprocessor directive `%s'", dname); goto fail; } free_tlist(origline); return (j ^ PP_COND_NEGATIVE(ct)) ? COND_IF_TRUE : COND_IF_FALSE; fail: free_tlist(origline); return COND_NEVER; } /* * Default smacro expansion routine: just returns a copy of the * expansion list. */ static Token * smacro_expand_default(const SMacro *s, Token **params, unsigned int nparams) { (void)params; (void)nparams; return dup_tlist(s->expansion, NULL); } /* * Emit a macro defintion or undef to the listing file, if * desired. This is similar to detoken(), but it handles the reverse * expansion list, does not expand %! or local variable tokens, and * does some special handling for macro parameters. */ static void list_smacro_def(enum preproc_token op, const Context *ctx, const SMacro *m) { static const Token unused_arg_name = { NULL, "", 0, TOK_OTHER }; const Token **param_names; Token *junk_names = NULL; Token *t; size_t namelen, size; unsigned int i; char *def, *p; char *context_prefix = NULL; size_t context_len; nasm_newn(param_names, m->nparam); namelen = strlen(m->name); size = namelen + 2; /* Include room for space after name + NUL */ if (ctx) { int context_depth = cstk->depth - ctx->depth + 1; context_prefix = nasm_asprintf("[%s::%"PRIu64"] %%%-*s", ctx->name ? ctx->name : "", ctx->number, context_depth, ""); context_len = nasm_last_string_len(); memset(context_prefix + context_len - context_depth, '$', context_depth); size += context_len; } list_for_each(t, m->expansion) { if (!t->text) { size++; /* Whitespace, presumably */ } else { size += t->len; if (is_smac_param(t->type)) param_names[smac_nparam(t->type)] = t; } } if (m->nparam) { /* * Space for ( and either , or ) around each * parameter, plus an optional =. */ size += 1 + 2 * m->nparam; for (i = 0; i < m->nparam; i++) { if (!param_names[i]) param_names[i] = &unused_arg_name; size += param_names[i]->len; } } def = nasm_malloc(size); p = def+size; *--p = '\0'; list_for_each(t, m->expansion) { if (!t->text) { *--p = ' '; } else { p -= t->len; memcpy(p, t->text, t->len); } } *--p = ' '; if (m->nparam) { *--p = ')'; for (i = m->nparam; i--;) { p -= param_names[i]->len; memcpy(p, param_names[i]->text, param_names[i]->len); if (m->eval_param && m->eval_param[i]) *--p = '='; *--p = ','; } *p = '('; /* First parameter starts with ( not , */ free_tlist(junk_names); } p -= namelen; memcpy(p, m->name, namelen); if (context_prefix) { p -= context_len; memcpy(p, context_prefix, context_len); nasm_free(context_prefix); } nasm_listmsg("%s %s", pp_directives[op], p); nasm_free(def); } /* * Common code for defining an smacro. The tmpl argument, if not NULL, * contains any macro parameters that aren't explicit arguments; * those are the more uncommon macro variants. */ static SMacro *define_smacro(const char *mname, bool casesense, Token *expansion, const SMacro *tmpl) { SMacro *smac, **smhead; struct hash_table *smtbl; Context *ctx; bool defining_alias = false; unsigned int nparam = 0; if (tmpl) { defining_alias = tmpl->alias; nparam = tmpl->nparam; } while (1) { ctx = get_ctx(mname, &mname); if (!smacro_defined(ctx, mname, nparam, &smac, casesense)) { /* Create a new macro */ smtbl = ctx ? &ctx->localmac : &smacros; smhead = (SMacro **) hash_findi_add(smtbl, mname); nasm_new(smac); smac->next = *smhead; *smhead = smac; break; } else if (!smac) { nasm_warn(WARN_OTHER, "single-line macro `%s' defined both with and" " without parameters", mname); /* * Some instances of the old code considered this a failure, * some others didn't. What is the right thing to do here? */ goto fail; } else if (!smac->alias || defining_alias) { /* * We're redefining, so we have to take over an * existing SMacro structure. This means freeing * what was already in it, but not the structure itself. */ clear_smacro(smac); break; } else if (smac->in_progress) { nasm_nonfatal("macro alias loop"); goto fail; } else { /* It is an alias macro; follow the alias link */ SMacro *s; smac->in_progress = true; s = define_smacro(smac->expansion->text, casesense, expansion, tmpl); smac->in_progress = false; return s; } } smac->name = nasm_strdup(mname); smac->casesense = casesense; smac->expansion = expansion; smac->expand = smacro_expand_default; if (tmpl) { smac->nparam = tmpl->nparam; smac->eval_param = tmpl->eval_param; smac->alias = tmpl->alias; if (tmpl->expand) smac->expand = tmpl->expand; } if (list_option('m')) { static const enum preproc_token op[2][2] = { { PP_DEFINE, PP_IDEFINE }, { PP_DEFALIAS, PP_IDEFALIAS } }; list_smacro_def(op[!!smac->alias][casesense], ctx, smac); } return smac; fail: free_tlist(expansion); if (tmpl && tmpl->eval_param) nasm_free(tmpl->eval_param); return NULL; } /* * Undefine an smacro */ static void undef_smacro(const char *mname, bool undefalias) { SMacro **smhead, *s, **sp; struct hash_table *smtbl; Context *ctx; ctx = get_ctx(mname, &mname); smtbl = ctx ? &ctx->localmac : &smacros; smhead = (SMacro **)hash_findi(smtbl, mname, NULL); if (smhead) { /* * We now have a macro name... go hunt for it. */ sp = smhead; while ((s = *sp) != NULL) { if (!mstrcmp(s->name, mname, s->casesense)) { if (s->alias && !undefalias) { if (s->in_progress) { nasm_nonfatal("macro alias loop"); } else { s->in_progress = true; undef_smacro(s->expansion->text, false); s->in_progress = false; } } else { if (list_option('m')) list_smacro_def(s->alias ? PP_UNDEFALIAS : PP_UNDEF, ctx, s); *sp = s->next; free_smacro(s); } } else { sp = &s->next; } } } } /* * Parse a mmacro specification. */ static bool parse_mmacro_spec(Token *tline, MMacro *def, const char *directive) { tline = tline->next; skip_white_(tline); tline = expand_id(tline); if (!tok_type_(tline, TOK_ID)) { nasm_nonfatal("`%s' expects a macro name", directive); return false; } def->prev = NULL; def->name = nasm_strdup(tline->text); def->plus = false; def->nolist = false; def->in_progress = 0; def->rep_nest = NULL; def->nparam_min = 0; def->nparam_max = 0; tline = expand_smacro(tline->next); skip_white_(tline); if (!tok_type_(tline, TOK_NUMBER)) nasm_nonfatal("`%s' expects a parameter count", directive); else def->nparam_min = def->nparam_max = read_param_count(tline->text); if (tline && tok_is_(tline->next, "-")) { tline = tline->next->next; if (tok_is_(tline, "*")) { def->nparam_max = INT_MAX; } else if (!tok_type_(tline, TOK_NUMBER)) { nasm_nonfatal("`%s' expects a parameter count after `-'", directive); } else { def->nparam_max = read_param_count(tline->text); if (def->nparam_min > def->nparam_max) { nasm_nonfatal("minimum parameter count exceeds maximum"); def->nparam_max = def->nparam_min; } } } if (tline && tok_is_(tline->next, "+")) { tline = tline->next; def->plus = true; } if (tline && tok_type_(tline->next, TOK_ID) && !nasm_stricmp(tline->next->text, ".nolist")) { tline = tline->next; def->nolist = !list_option('f') || istk->nolist; } /* * Handle default parameters. */ if (tline && tline->next) { def->dlist = tline->next; tline->next = NULL; count_mmac_params(def->dlist, &def->ndefs, &def->defaults); } else { def->dlist = NULL; def->defaults = NULL; } def->expansion = NULL; if (def->defaults && def->ndefs > def->nparam_max - def->nparam_min && !def->plus) { /* *!macro-defaults [on] macros with more default than optional parameters *! warns when a macro has more default parameters than optional parameters. *! See \k{mlmacdef} for why might want to disable this warning. */ nasm_warn(WARN_MACRO_DEFAULTS, "too many default macro parameters in macro `%s'", def->name); } return true; } /* * Decode a size directive */ static int parse_size(const char *str) { static const char *size_names[] = { "byte", "dword", "oword", "qword", "tword", "word", "yword" }; static const int sizes[] = { 0, 1, 4, 16, 8, 10, 2, 32 }; return str ? sizes[bsii(str, size_names, ARRAY_SIZE(size_names))+1] : 0; } /* * Process a preprocessor %pragma directive. Currently there are none. * Gets passed the token list starting with the "preproc" token from * "%pragma preproc". */ static void do_pragma_preproc(Token *tline) { /* Skip to the real stuff */ tline = tline->next; skip_white_(tline); if (!tline) return; (void)tline; /* Nothing else to do at present */ } static bool is_macro_id(const Token *t) { return t && (t->type == TOK_ID || (t->type == TOK_PREPROC_ID && t->text[1] == '$')); } static char *get_id(Token **tp, const char *dname, const char *err) { char *id; Token *t = *tp; t = t->next; /* Skip directive */ skip_white_(t); t = expand_id(t); if (!is_macro_id(t)) { nasm_nonfatal("`%s' expects a %s", dname, err ? err : "macro identifier"); return NULL; } id = t->text; skip_white_(t); *tp = t; return id; } /** * find and process preprocessor directive in passed line * Find out if a line contains a preprocessor directive, and deal * with it if so. * * If a directive _is_ found, it is the responsibility of this routine * (and not the caller) to free_tlist() the line. * * @param tline a pointer to the current tokeninzed line linked list * @param output if this directive generated output * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND * */ static int do_directive(Token *tline, Token **output) { enum preproc_token i; int j; bool err; int nparam; bool nolist; bool casesense; int k, m; int offset; char *p, *pp; const char *found_path; const char *mname; struct ppscan pps; Include *inc; Context *ctx; Cond *cond; MMacro *mmac, **mmhead; Token *t = NULL, *tt, *param_start, *macro_start, *last, *origline; Line *l; struct tokenval tokval; expr *evalresult; MMacro *tmp_defining; /* Used when manipulating rep_nest */ int64_t count; size_t len; errflags severity; const char *dname; /* Name of directive, for messages */ *output = NULL; /* No output generated */ origline = tline; skip_white_(tline); if (!tline || !tok_type_(tline, TOK_PREPROC_ID) || (tline->text[0] && (tline->text[1] == '%' || tline->text[1] == '$' || tline->text[1] == '!'))) return NO_DIRECTIVE_FOUND; dname = tline->text; i = pp_token_hash(tline->text); casesense = true; if (PP_HAS_CASE(i) & PP_INSENSITIVE(i)) { casesense = false; i--; } /* * If we're in a non-emitting branch of a condition construct, * or walking to the end of an already terminated %rep block, * we should ignore all directives except for condition * directives. */ if (((istk->conds && !emitting(istk->conds->state)) || (istk->mstk && !istk->mstk->in_progress)) && !is_condition(i)) { return NO_DIRECTIVE_FOUND; } /* * If we're defining a macro or reading a %rep block, we should * ignore all directives except for %macro/%imacro (which nest), * %endm/%endmacro, and (only if we're in a %rep block) %endrep. * If we're in a %rep block, another %rep nests, so should be let through. */ if (defining && i != PP_MACRO && i != PP_RMACRO && i != PP_ENDMACRO && i != PP_ENDM && (defining->name || (i != PP_ENDREP && i != PP_REP))) { return NO_DIRECTIVE_FOUND; } if (defining) { if (i == PP_MACRO || i == PP_RMACRO) { nested_mac_count++; return NO_DIRECTIVE_FOUND; } else if (nested_mac_count > 0) { if (i == PP_ENDMACRO) { nested_mac_count--; return NO_DIRECTIVE_FOUND; } } if (!defining->name) { if (i == PP_REP) { nested_rep_count++; return NO_DIRECTIVE_FOUND; } else if (nested_rep_count > 0) { if (i == PP_ENDREP) { nested_rep_count--; return NO_DIRECTIVE_FOUND; } } } } switch (i) { default: nasm_nonfatal("unknown preprocessor directive `%s'", dname); return NO_DIRECTIVE_FOUND; /* didn't get it */ case PP_PRAGMA: /* * %pragma namespace options... * * The namespace "preproc" is reserved for the preprocessor; * all other namespaces generate a [pragma] assembly directive. * * Invalid %pragmas are ignored and may have different * meaning in future versions of NASM. */ t = tline; tline = tline->next; t->next = NULL; tline = expand_smacro(tline); while (tok_type_(tline, TOK_WHITESPACE)) { t = tline; tline = tline->next; delete_Token(t); } if (tok_type_(tline, TOK_ID)) { if (!nasm_stricmp(tline->text, "preproc")) { /* Preprocessor pragma */ do_pragma_preproc(tline); free_tlist(tline); } else { /* Build the assembler directive */ /* Append bracket to the end of the output */ for (t = tline; t->next; t = t->next) ; t->next = new_Token(NULL, TOK_OTHER, "]", 1); /* Prepend "[pragma " */ t = new_Token(tline, TOK_WHITESPACE, NULL, 0); t = new_Token(t, TOK_ID, "pragma", 6); t = new_Token(t, TOK_OTHER, "[", 1); tline = t; *output = tline; } } break; case PP_STACKSIZE: /* Directive to tell NASM what the default stack size is. The * default is for a 16-bit stack, and this can be overriden with * %stacksize large. */ tline = tline->next; if (tline && tline->type == TOK_WHITESPACE) tline = tline->next; if (!tline || tline->type != TOK_ID) { nasm_nonfatal("`%s' missing size parameter", dname); } if (nasm_stricmp(tline->text, "flat") == 0) { /* All subsequent ARG directives are for a 32-bit stack */ StackSize = 4; StackPointer = "ebp"; ArgOffset = 8; LocalOffset = 0; } else if (nasm_stricmp(tline->text, "flat64") == 0) { /* All subsequent ARG directives are for a 64-bit stack */ StackSize = 8; StackPointer = "rbp"; ArgOffset = 16; LocalOffset = 0; } else if (nasm_stricmp(tline->text, "large") == 0) { /* All subsequent ARG directives are for a 16-bit stack, * far function call. */ StackSize = 2; StackPointer = "bp"; ArgOffset = 4; LocalOffset = 0; } else if (nasm_stricmp(tline->text, "small") == 0) { /* All subsequent ARG directives are for a 16-bit stack, * far function call. We don't support near functions. */ StackSize = 2; StackPointer = "bp"; ArgOffset = 6; LocalOffset = 0; } else { nasm_nonfatal("`%s' invalid size type", dname); } break; case PP_ARG: /* TASM like ARG directive to define arguments to functions, in * the following form: * * ARG arg1:WORD, arg2:DWORD, arg4:QWORD */ offset = ArgOffset; do { char *arg, directive[256]; int size = StackSize; /* Find the argument name */ tline = tline->next; if (tline && tline->type == TOK_WHITESPACE) tline = tline->next; if (!tline || tline->type != TOK_ID) { nasm_nonfatal("`%s' missing argument parameter", dname); goto done; } arg = tline->text; /* Find the argument size type */ tline = tline->next; if (!tline || tline->type != TOK_OTHER || tline->text[0] != ':') { nasm_nonfatal("syntax error processing `%s' directive", dname); goto done; } tline = tline->next; if (!tline || tline->type != TOK_ID) { nasm_nonfatal("`%s' missing size type parameter", dname); goto done; } /* Allow macro expansion of type parameter */ tt = tokenize(tline->text); tt = expand_smacro(tt); size = parse_size(tt->text); if (!size) { nasm_nonfatal("invalid size type for `%s' missing directive", dname); free_tlist(tt); goto done; } free_tlist(tt); /* Round up to even stack slots */ size = ALIGN(size, StackSize); /* Now define the macro for the argument */ snprintf(directive, sizeof(directive), "%%define %s (%s+%d)", arg, StackPointer, offset); do_directive(tokenize(directive), output); offset += size; /* Move to the next argument in the list */ tline = tline->next; if (tline && tline->type == TOK_WHITESPACE) tline = tline->next; } while (tline && tline->type == TOK_OTHER && tline->text[0] == ','); ArgOffset = offset; break; case PP_LOCAL: /* TASM like LOCAL directive to define local variables for a * function, in the following form: * * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize * * The '= LocalSize' at the end is ignored by NASM, but is * required by TASM to define the local parameter size (and used * by the TASM macro package). */ offset = LocalOffset; do { char *local, directive[256]; int size = StackSize; /* Find the argument name */ tline = tline->next; if (tline && tline->type == TOK_WHITESPACE) tline = tline->next; if (!tline || tline->type != TOK_ID) { nasm_nonfatal("`%s' missing argument parameter", dname); goto done; } local = tline->text; /* Find the argument size type */ tline = tline->next; if (!tline || tline->type != TOK_OTHER || tline->text[0] != ':') { nasm_nonfatal("syntax error processing `%s' directive", dname); goto done; } tline = tline->next; if (!tline || tline->type != TOK_ID) { nasm_nonfatal("`%s' missing size type parameter", dname); goto done; } /* Allow macro expansion of type parameter */ tt = tokenize(tline->text); tt = expand_smacro(tt); size = parse_size(tt->text); if (!size) { nasm_nonfatal("invalid size type for `%s' missing directive", dname); free_tlist(tt); goto done; } free_tlist(tt); /* Round up to even stack slots */ size = ALIGN(size, StackSize); offset += size; /* Negative offset, increment before */ /* Now define the macro for the argument */ snprintf(directive, sizeof(directive), "%%define %s (%s-%d)", local, StackPointer, offset); do_directive(tokenize(directive), output); /* Now define the assign to setup the enter_c macro correctly */ snprintf(directive, sizeof(directive), "%%assign %%$localsize %%$localsize+%d", size); do_directive(tokenize(directive), output); /* Move to the next argument in the list */ tline = tline->next; if (tline && tline->type == TOK_WHITESPACE) tline = tline->next; } while (tline && tline->type == TOK_OTHER && tline->text[0] == ','); LocalOffset = offset; break; case PP_CLEAR: if (tline->next) nasm_warn(WARN_OTHER, "trailing garbage after `%s' ignored", dname); free_macros(); init_macros(); break; case PP_DEPEND: t = tline->next = expand_smacro(tline->next); skip_white_(t); if (!t || (t->type != TOK_STRING && t->type != TOK_INTERNAL_STRING)) { nasm_nonfatal("`%s' expects a file name", dname); goto done; } if (t->next) nasm_warn(WARN_OTHER, "trailing garbage after `%s' ignored", dname); p = t->text; if (t->type != TOK_INTERNAL_STRING) nasm_unquote_cstr(p, NULL); strlist_add(deplist, p); goto done; case PP_INCLUDE: t = tline->next = expand_smacro(tline->next); skip_white_(t); if (!t || (t->type != TOK_STRING && t->type != TOK_INTERNAL_STRING)) { nasm_nonfatal("`%s' expects a file name", dname); goto done; } if (t->next) nasm_warn(WARN_OTHER, "trailing garbage after `%s' ignored", dname); p = t->text; if (t->type != TOK_INTERNAL_STRING) nasm_unquote_cstr(p, NULL); nasm_new(inc); inc->next = istk; inc->conds = NULL; found_path = NULL; inc->fp = inc_fopen(p, deplist, &found_path, (pp_mode == PP_DEPS) ? INC_OPTIONAL : INC_NEEDED, NF_TEXT); if (!inc->fp) { /* -MG given but file not found */ nasm_free(inc); } else { inc->fname = src_set_fname(found_path ? found_path : p); inc->lineno = src_set_linnum(0); inc->lineinc = 1; inc->expansion = NULL; inc->mstk = NULL; inc->nolist = istk->nolist; istk = inc; lfmt->uplevel(LIST_INCLUDE, 0); } break; case PP_USE: { const struct use_package *pkg; if (!(mname = get_id(&tline, dname, "package name"))) goto done; if (tline->next) nasm_warn(WARN_OTHER, "trailing garbage after `%s' ignored", dname); if (tline->type == TOK_STRING) nasm_unquote_cstr(tline->text, NULL); pkg = nasm_find_use_package(tline->text); if (!pkg) { nasm_nonfatal("unknown `%s' package: %s", dname, tline->text); } else if (!use_loaded[pkg->index]) { /* * Not already included, go ahead and include it. * Treat it as an include file for the purpose of * producing a listing. */ use_loaded[pkg->index] = true; stdmacpos = pkg->macros; nasm_new(inc); inc->next = istk; inc->fname = src_set_fname(NULL); inc->lineno = src_set_linnum(0); inc->lineinc = 0; inc->expansion = NULL; inc->mstk = NULL; inc->nolist = !list_option('b') || istk->nolist; istk = inc; lfmt->uplevel(LIST_INCLUDE, 0); } break; } case PP_PUSH: case PP_REPL: case PP_POP: tline = tline->next; skip_white_(tline); tline = expand_id(tline); if (tline) { if (!tok_type_(tline, TOK_ID)) { nasm_nonfatal("`%s' expects a context identifier", pp_directives[i]); goto done; } if (tline->next) nasm_warn(WARN_OTHER, "trailing garbage after `%s' ignored", pp_directives[i]); p = nasm_strdup(tline->text); } else { p = NULL; /* Anonymous */ } if (i == PP_PUSH) { nasm_new(ctx); ctx->depth = cstk ? cstk->depth + 1 : 1; ctx->next = cstk; ctx->name = p; ctx->number = unique++; cstk = ctx; } else { /* %pop or %repl */ if (!cstk) { nasm_nonfatal("`%s': context stack is empty", pp_directives[i]); } else if (i == PP_POP) { if (p && (!cstk->name || nasm_stricmp(p, cstk->name))) nasm_nonfatal("`%s' in wrong context: %s, " "expected %s", dname, cstk->name ? cstk->name : "anonymous", p); else ctx_pop(); } else { /* i == PP_REPL */ nasm_free(cstk->name); cstk->name = p; p = NULL; } nasm_free(p); } break; case PP_FATAL: severity = ERR_FATAL; goto issue_error; case PP_ERROR: severity = ERR_NONFATAL|ERR_PASS2; goto issue_error; case PP_WARNING: /*! *!user [on] %warning directives *! controls output of \c{%warning} directives (see \k{pperror}). */ severity = ERR_WARNING|WARN_USER|ERR_PASS2; goto issue_error; issue_error: { /* Only error out if this is the final pass */ tline->next = expand_smacro(tline->next); tline = tline->next; skip_white_(tline); t = tline ? tline->next : NULL; skip_white_(t); if (tok_type_(tline, TOK_STRING) && !t) { /* The line contains only a quoted string */ p = tline->text; nasm_unquote(p, NULL); /* Ignore NUL character truncation */ nasm_error(severity, "%s", p); } else { /* Not a quoted string, or more than a quoted string */ p = detoken(tline, false); nasm_error(severity, "%s", p); nasm_free(p); } break; } CASE_PP_IF: if (istk->conds && !emitting(istk->conds->state)) j = COND_NEVER; else { j = if_condition(tline->next, i); tline->next = NULL; /* it got freed */ } cond = nasm_malloc(sizeof(Cond)); cond->next = istk->conds; cond->state = j; istk->conds = cond; if(istk->mstk) istk->mstk->condcnt++; break; CASE_PP_ELIF: if (!istk->conds) nasm_fatal("`%s': no matching `%%if'", dname); switch(istk->conds->state) { case COND_IF_TRUE: istk->conds->state = COND_DONE; break; case COND_DONE: case COND_NEVER: break; case COND_ELSE_TRUE: case COND_ELSE_FALSE: nasm_warn(WARN_OTHER|ERR_PP_PRECOND, "`%%elif' after `%%else' ignored"); istk->conds->state = COND_NEVER; break; case COND_IF_FALSE: /* * IMPORTANT: In the case of %if, we will already have * called expand_mmac_params(); however, if we're * processing an %elif we must have been in a * non-emitting mode, which would have inhibited * the normal invocation of expand_mmac_params(). * Therefore, we have to do it explicitly here. */ j = if_condition(expand_mmac_params(tline->next), i); tline->next = NULL; /* it got freed */ istk->conds->state = j; break; } break; case PP_ELSE: if (tline->next) nasm_warn(WARN_OTHER|ERR_PP_PRECOND, "trailing garbage after `%%else' ignored"); if (!istk->conds) nasm_fatal("`%%else: no matching `%%if'"); switch(istk->conds->state) { case COND_IF_TRUE: case COND_DONE: istk->conds->state = COND_ELSE_FALSE; break; case COND_NEVER: break; case COND_IF_FALSE: istk->conds->state = COND_ELSE_TRUE; break; case COND_ELSE_TRUE: case COND_ELSE_FALSE: nasm_warn(WARN_OTHER|ERR_PP_PRECOND, "`%%else' after `%%else' ignored."); istk->conds->state = COND_NEVER; break; } break; case PP_ENDIF: if (tline->next) nasm_warn(WARN_OTHER|ERR_PP_PRECOND, "trailing garbage after `%%endif' ignored"); if (!istk->conds) nasm_fatal("`%%endif': no matching `%%if'"); cond = istk->conds; istk->conds = cond->next; nasm_free(cond); if(istk->mstk) istk->mstk->condcnt--; break; case PP_RMACRO: case PP_MACRO: if (defining) nasm_fatal("`%s': already defining a macro", dname); defining = nasm_zalloc(sizeof(MMacro)); defining->max_depth = nasm_limit[LIMIT_MACRO_LEVELS]; defining->casesense = casesense; if (!parse_mmacro_spec(tline, defining, dname)) { nasm_free(defining); goto done; } src_get(&defining->xline, &defining->fname); mmac = (MMacro *) hash_findix(&mmacros, defining->name); while (mmac) { if (!strcmp(mmac->name, defining->name) && (mmac->nparam_min <= defining->nparam_max || defining->plus) && (defining->nparam_min <= mmac->nparam_max || mmac->plus)) { nasm_warn(WARN_OTHER, "redefining multi-line macro `%s'", defining->name); break; } mmac = mmac->next; } break; case PP_ENDM: case PP_ENDMACRO: if (!(defining && defining->name)) { nasm_nonfatal("`%s': not defining a macro", tline->text); goto done; } mmhead = (MMacro **) hash_findi_add(&mmacros, defining->name); defining->next = *mmhead; *mmhead = defining; defining = NULL; break; case PP_EXITMACRO: /* * We must search along istk->expansion until we hit a * macro-end marker for a macro with a name. Then we * bypass all lines between exitmacro and endmacro. */ list_for_each(l, istk->expansion) if (l->finishes && l->finishes->name) break; if (l) { /* * Remove all conditional entries relative to this * macro invocation. (safe to do in this context) */ for ( ; l->finishes->condcnt > 0; l->finishes->condcnt --) { cond = istk->conds; istk->conds = cond->next; nasm_free(cond); } istk->expansion = l; } else { nasm_nonfatal("`%%exitmacro' not within `%%macro' block"); } break; case PP_UNIMACRO: casesense = false; /* fall through */ case PP_UNMACRO: { MMacro **mmac_p; MMacro spec; spec.casesense = casesense; if (!parse_mmacro_spec(tline, &spec, dname)) { goto done; } mmac_p = (MMacro **) hash_findi(&mmacros, spec.name, NULL); while (mmac_p && *mmac_p) { mmac = *mmac_p; if (mmac->casesense == spec.casesense && !mstrcmp(mmac->name, spec.name, spec.casesense) && mmac->nparam_min == spec.nparam_min && mmac->nparam_max == spec.nparam_max && mmac->plus == spec.plus) { *mmac_p = mmac->next; free_mmacro(mmac); } else { mmac_p = &mmac->next; } } free_tlist(spec.dlist); break; } case PP_ROTATE: if (tline->next && tline->next->type == TOK_WHITESPACE) tline = tline->next; if (!tline->next) { free_tlist(origline); nasm_nonfatal("`%%rotate' missing rotate count"); return DIRECTIVE_FOUND; } t = expand_smacro(tline->next); tline->next = NULL; pps.tptr = tline = t; pps.ntokens = -1; tokval.t_type = TOKEN_INVALID; evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); free_tlist(tline); if (!evalresult) return DIRECTIVE_FOUND; if (tokval.t_type) nasm_warn(WARN_OTHER, "trailing garbage after expression ignored"); if (!is_simple(evalresult)) { nasm_nonfatal("non-constant value given to `%%rotate'"); return DIRECTIVE_FOUND; } mmac = istk->mstk; while (mmac && !mmac->name) /* avoid mistaking %reps for macros */ mmac = mmac->next_active; if (!mmac) { nasm_nonfatal("`%%rotate' invoked outside a macro call"); } else if (mmac->nparam == 0) { nasm_nonfatal("`%%rotate' invoked within macro without parameters"); } else { int rotate = mmac->rotate + reloc_value(evalresult); rotate %= (int)mmac->nparam; if (rotate < 0) rotate += mmac->nparam; mmac->rotate = rotate; } break; case PP_REP: nolist = false; do { tline = tline->next; } while (tok_type_(tline, TOK_WHITESPACE)); if (tok_type_(tline, TOK_ID) && nasm_stricmp(tline->text, ".nolist") == 0) { nolist = !list_option('f') || istk->nolist; do { tline = tline->next; } while (tok_type_(tline, TOK_WHITESPACE)); } if (tline) { pps.tptr = expand_smacro(tline); pps.ntokens = -1; tokval.t_type = TOKEN_INVALID; /* XXX: really critical?! */ evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); if (!evalresult) goto done; if (tokval.t_type) nasm_warn(WARN_OTHER, "trailing garbage after expression ignored"); if (!is_simple(evalresult)) { nasm_nonfatal("non-constant value given to `%%rep'"); goto done; } count = reloc_value(evalresult); if (count > nasm_limit[LIMIT_REP]) { nasm_nonfatal("`%%rep' count %"PRId64" exceeds limit (currently %"PRId64")", count, nasm_limit[LIMIT_REP]); count = 0; } else if (count < 0) { /*! *!negative-rep [on] regative %rep count *! warns about negative counts given to the \c{%rep} *! preprocessor directive. */ nasm_warn(ERR_PASS2|WARN_NEGATIVE_REP, "negative `%%rep' count: %"PRId64, count); count = 0; } else { count++; } } else { nasm_nonfatal("`%%rep' expects a repeat count"); count = 0; } tmp_defining = defining; nasm_new(defining); defining->nolist = nolist; defining->in_progress = count; defining->next_active = istk->mstk; defining->rep_nest = tmp_defining; src_get(&defining->xline, &defining->fname); break; case PP_ENDREP: if (!defining || defining->name) { nasm_nonfatal("`%%endrep': no matching `%%rep'"); goto done; } /* * Now we have a "macro" defined - although it has no name * and we won't be entering it in the hash tables - we must * push a macro-end marker for it on to istk->expansion. * After that, it will take care of propagating itself (a * macro-end marker line for a macro which is really a %rep * block will cause the macro to be re-expanded, complete * with another macro-end marker to ensure the process * continues) until the whole expansion is forcibly removed * from istk->expansion by a %exitrep. */ nasm_new(l); l->next = istk->expansion; l->finishes = defining; l->first = NULL; istk->expansion = l; istk->mstk = defining; lfmt->uplevel(defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO, 0); tmp_defining = defining; defining = defining->rep_nest; break; case PP_EXITREP: /* * We must search along istk->expansion until we hit a * macro-end marker for a macro with no name. Then we set * its `in_progress' flag to 0. */ list_for_each(l, istk->expansion) if (l->finishes && !l->finishes->name) break; if (l) l->finishes->in_progress = 1; else nasm_nonfatal("`%%exitrep' not within `%%rep' block"); break; case PP_DEFINE: case PP_XDEFINE: case PP_DEFALIAS: { bool have_eval_params = false; bool *eval_params = NULL; SMacro tmpl; if (!(mname = get_id(&tline, dname, NULL))) goto done; nasm_zero(tmpl); last = tline; param_start = tline = tline->next; nparam = 0; if (tok_is_(tline, "(")) { /* * This macro has parameters. */ tline = tline->next; while (1) { skip_white_(tline); if (!tline) { nasm_nonfatal("parameter identifier expected"); goto done; } if (tok_is_(tline, "=")) { have_eval_params = true; tline = tline->next; skip_white_(tline); } /* * "*" means an unnamed, ignored argument; it can never * match anything because "*" is not TOK_ID, and so * none of the expansion entries will be converted * to parameters. */ if (tline->type != TOK_ID) { if (tok_is_(tline, ",") || tok_is_(tline, ")")) { /* * Empty name; duplicate the termination * token and use the first copy as a placeholder. * It will never match anything, since the * associated text doesn't correspond to a TOK_ID. */ tline = dup_Token(tline, tline); } else { nasm_nonfatal("`%s': parameter identifier expected", tline->text); goto done; } } tline->type = tok_smac_param(nparam++); tline = tline->next; skip_white_(tline); if (tok_is_(tline, ",")) { tline = tline->next; } else { if (!tok_is_(tline, ")")) { nasm_nonfatal("`)' expected to terminate macro template"); goto done; } break; } } last = tline; tline = tline->next; if (have_eval_params) { /* Create evaluated parameters table */ bool is_eval = false; nasm_newn(eval_params, nparam); list_for_each(tt, param_start) { if (is_smac_param(tt->type)) eval_params[smac_nparam(tt->type)] = is_eval; is_eval = tok_is_(tt, "="); } } } if (tok_type_(tline, TOK_WHITESPACE)) last = tline, tline = tline->next; last->next = NULL; if (unlikely(i == PP_DEFALIAS)) { macro_start = tline; if (!is_macro_id(macro_start)) { nasm_nonfatal("`%s' expects a macro identifier to alias", dname); goto done; } tt = macro_start->next; macro_start->next = NULL; tline = tline->next; skip_white_(tline); if (tline && tline->type) { nasm_warn(WARN_OTHER, "trailing garbage after aliasing identifier ignored"); } free_tlist(tt); tmpl.alias = true; } else { /* Expand the macro definition now for %xdefine and %ixdefine */ if (i == PP_XDEFINE) tline = expand_smacro(tline); macro_start = NULL; t = tline; while (t) { if (t->type == TOK_ID) { list_for_each(tt, param_start) if (is_smac_param(tt->type) && tt->len == t->len && !memcmp(tt->text, t->text, tt->len)) t->type = tt->type; } tt = t->next; t->next = macro_start; macro_start = t; t = tt; } } /* * Good. We now have a macro name, a parameter count, and a * token list (in reverse order) for an expansion. We ought * to be OK just to create an SMacro, store it, and let * free_tlist have the rest of the line (which we have * carefully re-terminated after chopping off the expansion * from the end). */ tmpl.nparam = nparam; tmpl.eval_param = eval_params; define_smacro(mname, casesense, macro_start, &tmpl); break; } case PP_UNDEF: case PP_UNDEFALIAS: if (!(mname = get_id(&tline, dname, NULL))) goto done; if (tline->next) nasm_warn(WARN_OTHER, "trailing garbage after macro name ignored"); undef_smacro(mname, i == PP_UNDEFALIAS); break; case PP_DEFSTR: if (!(mname = get_id(&tline, dname, NULL))) goto done; last = tline; tline = expand_smacro(tline->next); last->next = NULL; while (tok_type_(tline, TOK_WHITESPACE)) tline = delete_Token(tline); p = detoken(tline, false); macro_start = make_tok_qstr(p); nasm_free(p); /* * We now have a macro name, an implicit parameter count of * zero, and a string token to use as an expansion. Create * and store an SMacro. */ define_smacro(mname, casesense, macro_start, NULL); break; case PP_DEFTOK: if (!(mname = get_id(&tline, dname, NULL))) goto done; last = tline; tline = expand_smacro(tline->next); last->next = NULL; t = tline; while (tok_type_(t, TOK_WHITESPACE)) t = t->next; /* t should now point to the string */ if (!tok_type_(t, TOK_STRING)) { nasm_nonfatal("`%s' requires string as second parameter", dname); free_tlist(tline); goto done; } /* * Convert the string to a token stream. Note that smacros * are stored with the token stream reversed, so we have to * reverse the output of tokenize(). */ nasm_unquote_cstr(t->text, NULL); macro_start = reverse_tokens(tokenize(t->text)); /* * We now have a macro name, an implicit parameter count of * zero, and a numeric token to use as an expansion. Create * and store an SMacro. */ define_smacro(mname, casesense, macro_start, NULL); free_tlist(tline); break; case PP_PATHSEARCH: { const char *found_path; if (!(mname = get_id(&tline, dname, NULL))) goto done; last = tline; tline = expand_smacro(tline->next); last->next = NULL; t = tline; while (tok_type_(t, TOK_WHITESPACE)) t = t->next; if (!t || (t->type != TOK_STRING && t->type != TOK_INTERNAL_STRING)) { nasm_nonfatal("`%s' expects a file name", dname); free_tlist(tline); goto done; } if (t->next) nasm_warn(WARN_OTHER, "trailing garbage after `%s' ignored", dname); p = t->text; if (t->type != TOK_INTERNAL_STRING) nasm_unquote(p, NULL); inc_fopen(p, NULL, &found_path, INC_PROBE, NF_BINARY); if (!found_path) found_path = p; macro_start = make_tok_qstr(found_path); /* * We now have a macro name, an implicit parameter count of * zero, and a string token to use as an expansion. Create * and store an SMacro. */ define_smacro(mname, casesense, macro_start, NULL); free_tlist(tline); break; } case PP_STRLEN: if (!(mname = get_id(&tline, dname, NULL))) goto done; last = tline; tline = expand_smacro(tline->next); last->next = NULL; t = tline; while (tok_type_(t, TOK_WHITESPACE)) t = t->next; /* t should now point to the string */ if (!tok_type_(t, TOK_STRING)) { nasm_nonfatal("`%s' requires string as second parameter", dname); free_tlist(tline); free_tlist(origline); return DIRECTIVE_FOUND; } macro_start = make_tok_num(nasm_unquote(t->text, NULL)); /* * We now have a macro name, an implicit parameter count of * zero, and a numeric token to use as an expansion. Create * and store an SMacro. */ define_smacro(mname, casesense, macro_start, NULL); free_tlist(tline); free_tlist(origline); return DIRECTIVE_FOUND; case PP_STRCAT: if (!(mname = get_id(&tline, dname, NULL))) goto done; last = tline; tline = expand_smacro(tline->next); last->next = NULL; len = 0; list_for_each(t, tline) { switch (t->type) { case TOK_WHITESPACE: break; case TOK_STRING: len += t->len = nasm_unquote(t->text, NULL); break; case TOK_OTHER: if (!strcmp(t->text, ",")) /* permit comma separators */ break; /* else fall through */ default: nasm_nonfatal("non-string passed to `%s': %s", dname, t->text); free_tlist(tline); goto done; } } p = pp = nasm_malloc(len); list_for_each(t, tline) { if (t->type == TOK_STRING) { memcpy(p, t->text, t->len); p += t->len; } } /* * We now have a macro name, an implicit parameter count of * zero, and a numeric token to use as an expansion. Create * and store an SMacro. */ macro_start = make_tok_qstr(pp); nasm_free(pp); define_smacro(mname, casesense, macro_start, NULL); free_tlist(tline); break; case PP_SUBSTR: { int64_t start, count; size_t len; if (!(mname = get_id(&tline, dname, NULL))) goto done; last = tline; tline = expand_smacro(tline->next); last->next = NULL; if (tline) /* skip expanded id */ t = tline->next; while (tok_type_(t, TOK_WHITESPACE)) t = t->next; /* t should now point to the string */ if (!tok_type_(t, TOK_STRING)) { nasm_nonfatal("`%s' requires string as second parameter", dname); free_tlist(tline); goto done; } pps.tptr = t->next; pps.ntokens = -1; tokval.t_type = TOKEN_INVALID; evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); if (!evalresult) { free_tlist(tline); goto done; } else if (!is_simple(evalresult)) { nasm_nonfatal("non-constant value given to `%s'", dname); free_tlist(tline); goto done; } start = evalresult->value - 1; while (tok_type_(pps.tptr, TOK_WHITESPACE)) pps.tptr = pps.tptr->next; if (!pps.tptr) { count = 1; /* Backwards compatibility: one character */ } else { tokval.t_type = TOKEN_INVALID; evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); if (!evalresult) { free_tlist(tline); goto done; } else if (!is_simple(evalresult)) { nasm_nonfatal("non-constant value given to `%s'", dname); free_tlist(tline); goto done; } count = evalresult->value; } len = nasm_unquote(t->text, NULL); /* make start and count being in range */ if (start < 0) start = 0; if (count < 0) count = len + count + 1 - start; if (start + count > (int64_t)len) count = len - start; if (!len || count < 0 || start >=(int64_t)len) start = -1, count = 0; /* empty string */ macro_start = new_Token(NULL, TOK_STRING, NULL, 0); macro_start->len = count; macro_start->text = nasm_quote((start < 0) ? "" : t->text + start, ¯o_start->len); /* * We now have a macro name, an implicit parameter count of * zero, and a numeric token to use as an expansion. Create * and store an SMacro. */ define_smacro(mname, casesense, macro_start, NULL); free_tlist(tline); break; } case PP_ASSIGN: if (!(mname = get_id(&tline, dname, NULL))) goto done; last = tline; tline = expand_smacro(tline->next); last->next = NULL; pps.tptr = tline; pps.ntokens = -1; tokval.t_type = TOKEN_INVALID; evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); free_tlist(tline); if (!evalresult) goto done; if (tokval.t_type) nasm_warn(WARN_OTHER, "trailing garbage after expression ignored"); if (!is_simple(evalresult)) { nasm_nonfatal("non-constant value given to `%s'", dname); free_tlist(origline); return DIRECTIVE_FOUND; } macro_start = make_tok_num(reloc_value(evalresult)); /* * We now have a macro name, an implicit parameter count of * zero, and a numeric token to use as an expansion. Create * and store an SMacro. */ define_smacro(mname, casesense, macro_start, NULL); break; case PP_LINE: /* * Syntax is `%line nnn[+mmm] [filename]' */ if (unlikely(pp_noline)) goto done; tline = tline->next; skip_white_(tline); if (!tok_type_(tline, TOK_NUMBER)) { nasm_nonfatal("`%s' expects line number", dname); goto done; } k = readnum(tline->text, &err); m = 1; tline = tline->next; if (tok_is_(tline, "+")) { tline = tline->next; if (!tok_type_(tline, TOK_NUMBER)) { nasm_nonfatal("`%s' expects line increment", dname); goto done; } m = readnum(tline->text, &err); tline = tline->next; } skip_white_(tline); src_set_linnum(k); istk->lineinc = m; if (tline) { char *fname = detoken(tline, false); src_set_fname(fname); nasm_free(fname); } break; } done: free_tlist(origline); return DIRECTIVE_FOUND; } /* * Ensure that a macro parameter contains a condition code and * nothing else. Return the condition code index if so, or -1 * otherwise. */ static int find_cc(Token * t) { Token *tt; if (!t) return -1; /* Probably a %+ without a space */ skip_white_(t); if (!t) return -1; if (t->type != TOK_ID) return -1; tt = t->next; skip_white_(tt); if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ","))) return -1; return bsii(t->text, (const char **)conditions, ARRAY_SIZE(conditions)); } /* * This routines walks over tokens strem and handles tokens * pasting, if @handle_explicit passed then explicit pasting * term is handled, otherwise -- implicit pastings only. * The @m array can contain a series of token types which are * executed as separate passes. */ static bool paste_tokens(Token **head, const struct tokseq_match *m, size_t mnum, bool handle_explicit) { Token *tok, *next, **prev_next, **prev_nonspace; bool pasted = false; char *buf, *p; size_t len, i; /* * The last token before pasting. We need it * to be able to connect new handled tokens. * In other words if there were a tokens stream * * A -> B -> C -> D * * and we've joined tokens B and C, the resulting * stream should be * * A -> BC -> D */ tok = *head; prev_next = NULL; if (!tok_type_(tok, TOK_WHITESPACE) && !tok_type_(tok, TOK_PASTE)) prev_nonspace = head; else prev_nonspace = NULL; while (tok && (next = tok->next)) { switch (tok->type) { case TOK_WHITESPACE: /* Zap redundant whitespaces */ while (tok_type_(next, TOK_WHITESPACE)) next = delete_Token(next); tok->next = next; break; case TOK_PASTE: /* Explicit pasting */ if (!handle_explicit) break; next = delete_Token(tok); while (tok_type_(next, TOK_WHITESPACE)) next = delete_Token(next); if (!pasted) pasted = true; /* Left pasting token is start of line */ if (!prev_nonspace) nasm_fatal("No lvalue found on pasting"); /* * No ending token, this might happen in two * cases * * 1) There indeed no right token at all * 2) There is a bare "%define ID" statement, * and @ID does expand to whitespace. * * So technically we need to do a grammar analysis * in another stage of parsing, but for now lets don't * change the behaviour people used to. Simply allow * whitespace after paste token. */ if (!next) { /* * Zap ending space tokens and that's all. */ tok = (*prev_nonspace)->next; while (tok_type_(tok, TOK_WHITESPACE)) tok = delete_Token(tok); tok = *prev_nonspace; tok->next = NULL; break; } tok = *prev_nonspace; while (tok_type_(tok, TOK_WHITESPACE)) tok = delete_Token(tok); len = strlen(tok->text); len += strlen(next->text); p = buf = nasm_malloc(len + 1); strcpy(p, tok->text); p = strchr(p, '\0'); strcpy(p, next->text); delete_Token(tok); tok = tokenize(buf); nasm_free(buf); *prev_nonspace = tok; while (tok && tok->next) tok = tok->next; tok->next = delete_Token(next); /* Restart from pasted tokens head */ tok = *prev_nonspace; break; default: /* implicit pasting */ for (i = 0; i < mnum; i++) { if (!(PP_CONCAT_MATCH(tok, m[i].mask_head))) continue; len = 0; while (next && PP_CONCAT_MATCH(next, m[i].mask_tail)) { len += strlen(next->text); next = next->next; } /* No match or no text to process */ if (tok == next || len == 0) break; len += strlen(tok->text); p = buf = nasm_malloc(len + 1); strcpy(p, tok->text); p = strchr(p, '\0'); tok = delete_Token(tok); while (tok != next) { if (PP_CONCAT_MATCH(tok, m[i].mask_tail)) { strcpy(p, tok->text); p = strchr(p, '\0'); } tok = delete_Token(tok); } tok = tokenize(buf); nasm_free(buf); if (prev_next) *prev_next = tok; else *head = tok; /* * Connect pasted into original stream, * ie A -> new-tokens -> B */ while (tok && tok->next) tok = tok->next; tok->next = next; if (!pasted) pasted = true; /* Restart from pasted tokens head */ tok = prev_next ? *prev_next : *head; } break; } prev_next = &tok->next; if (tok->next && !tok_type_(tok->next, TOK_WHITESPACE) && !tok_type_(tok->next, TOK_PASTE)) prev_nonspace = prev_next; tok = tok->next; } return pasted; } /* * expands to a list of tokens from %{x:y} */ static Token *expand_mmac_params_range(MMacro *mac, Token *tline, Token ***last) { Token *t = tline, **tt, *tm, *head; char *pos; int fst, lst, j, i; pos = strchr(tline->text, ':'); nasm_assert(pos); lst = atoi(pos + 1); fst = atoi(tline->text + 1); /* * only macros params are accounted so * if someone passes %0 -- we reject such * value(s) */ if (lst == 0 || fst == 0) goto err; /* the values should be sane */ if ((fst > (int)mac->nparam || fst < (-(int)mac->nparam)) || (lst > (int)mac->nparam || lst < (-(int)mac->nparam))) goto err; fst = fst < 0 ? fst + (int)mac->nparam + 1: fst; lst = lst < 0 ? lst + (int)mac->nparam + 1: lst; /* counted from zero */ fst--, lst--; /* * It will be at least one token. Note we * need to scan params until separator, otherwise * only first token will be passed. */ tm = mac->params[(fst + mac->rotate) % mac->nparam]; if (!tm) goto err; head = dup_Token(NULL, tm); tt = &head->next, tm = tm->next; while (tok_isnt_(tm, ",")) { t = dup_Token(NULL, tm); *tt = t, tt = &t->next, tm = tm->next; } if (fst < lst) { for (i = fst + 1; i <= lst; i++) { t = new_Token(NULL, TOK_OTHER, ",", 0); *tt = t, tt = &t->next; j = (i + mac->rotate) % mac->nparam; tm = mac->params[j]; while (tok_isnt_(tm, ",")) { t = dup_Token(NULL, tm); *tt = t, tt = &t->next, tm = tm->next; } } } else { for (i = fst - 1; i >= lst; i--) { t = new_Token(NULL, TOK_OTHER, ",", 0); *tt = t, tt = &t->next; j = (i + mac->rotate) % mac->nparam; tm = mac->params[j]; while (tok_isnt_(tm, ",")) { t = dup_Token(NULL, tm); *tt = t, tt = &t->next, tm = tm->next; } } } *last = tt; return head; err: nasm_nonfatal("`%%{%s}': macro parameters out of range", &tline->text[1]); return tline; } /* * Expand MMacro-local things: parameter references (%0, %n, %+n, * %-n) and MMacro-local identifiers (%%foo) as well as * macro indirection (%[...]) and range (%{..:..}). */ static Token *expand_mmac_params(Token * tline) { Token *t, *tt, **tail, *thead; bool changed = false; char *pos; tail = &thead; thead = NULL; while (tline) { if (tline->type == TOK_PREPROC_ID && tline->text && tline->text[0] && (((tline->text[1] == '+' || tline->text[1] == '-') && tline->text[2]) || (tline->text[1] >= '0' && tline->text[1] <= '9') || tline->text[1] == '%')) { char *text = NULL; int type = 0, cc; /* type = 0 to placate optimisers */ char tmpbuf[30]; unsigned int n; int i; MMacro *mac; t = tline; tline = tline->next; mac = istk->mstk; while (mac && !mac->name) /* avoid mistaking %reps for macros */ mac = mac->next_active; if (!mac) { nasm_nonfatal("`%s': not in a macro call", t->text); } else { pos = strchr(t->text, ':'); if (!pos) { switch (t->text[1]) { /* * We have to make a substitution of one of the * forms %1, %-1, %+1, %%foo, %0. */ case '0': type = TOK_NUMBER; snprintf(tmpbuf, sizeof(tmpbuf), "%d", mac->nparam); text = nasm_strdup(tmpbuf); break; case '%': type = TOK_ID; snprintf(tmpbuf, sizeof(tmpbuf), "..@%"PRIu64".", mac->unique); text = nasm_strcat(tmpbuf, t->text + 2); break; case '-': n = atoi(t->text + 2) - 1; if (n >= mac->nparam) tt = NULL; else { if (mac->nparam > 1) n = (n + mac->rotate) % mac->nparam; tt = mac->params[n]; } cc = find_cc(tt); if (cc == -1) { nasm_nonfatal("macro parameter %d is not a condition code", n + 1); text = NULL; } else { type = TOK_ID; if (inverse_ccs[cc] == -1) { nasm_nonfatal("condition code `%s' is not invertible", conditions[cc]); text = NULL; } else text = nasm_strdup(conditions[inverse_ccs[cc]]); } break; case '+': n = atoi(t->text + 2) - 1; if (n >= mac->nparam) tt = NULL; else { if (mac->nparam > 1) n = (n + mac->rotate) % mac->nparam; tt = mac->params[n]; } cc = find_cc(tt); if (cc == -1) { nasm_nonfatal("macro parameter %d is not a condition code", n + 1); text = NULL; } else { type = TOK_ID; text = nasm_strdup(conditions[cc]); } break; default: n = atoi(t->text + 1) - 1; if (n >= mac->nparam) tt = NULL; else { if (mac->nparam > 1) n = (n + mac->rotate) % mac->nparam; tt = mac->params[n]; } if (tt) { for (i = 0; i < mac->paramlen[n]; i++) { *tail = dup_Token(NULL, tt); tail = &(*tail)->next; tt = tt->next; } } text = NULL; /* we've done it here */ break; } } else { /* * seems we have a parameters range here */ Token *head, **last; head = expand_mmac_params_range(mac, t, &last); if (head != t) { *tail = head; *last = tline; tline = head; text = NULL; } } } if (!text) { delete_Token(t); } else { *tail = t; tail = &t->next; t->type = type; nasm_free(t->text); t->text = text; t->len = strlen(text); } changed = true; continue; } else if (tline->type == TOK_INDIRECT) { t = tline; tline = tline->next; tt = tokenize(t->text); tt = expand_mmac_params(tt); tt = expand_smacro(tt); *tail = tt; while (tt) { tail = &tt->next; tt = tt->next; } delete_Token(t); changed = true; } else { t = *tail = tline; tline = tline->next; tail = &t->next; } } *tail = NULL; if (changed) { const struct tokseq_match t[] = { { PP_CONCAT_MASK(TOK_ID) | PP_CONCAT_MASK(TOK_FLOAT), /* head */ PP_CONCAT_MASK(TOK_ID) | PP_CONCAT_MASK(TOK_NUMBER) | PP_CONCAT_MASK(TOK_FLOAT) | PP_CONCAT_MASK(TOK_OTHER) /* tail */ }, { PP_CONCAT_MASK(TOK_NUMBER), /* head */ PP_CONCAT_MASK(TOK_NUMBER) /* tail */ } }; paste_tokens(&thead, t, ARRAY_SIZE(t), false); } return thead; } static Token *expand_smacro_noreset(Token * tline); static struct { int64_t tokens; int64_t levels; bool triggered; } smacro_deadman; /* * Expand *one* single-line macro instance. If the first token is not * a macro at all, it is simply copied to the output and the pointer * advanced. tpp should be a pointer to a pointer (usually the next * pointer of the previous token) to the first token. **tpp is updated * to point to the last token of the expansion, and *tpp updated to * point to the next pointer of the first token of the expansion. * * If the expansion is empty, *tpp will be unchanged but **tpp will * be advanced past the macro call. * * Return the macro expanded, or NULL if no expansion took place. */ static SMacro *expand_one_smacro(Token ***tpp) { Token **params = NULL; const char *mname; Token *tline = **tpp; Token *mstart = **tpp; SMacro *head, *m; unsigned int i; Token *t, *tup, *ttail; unsigned int nparam = 0; if (!tline) return false; /* Empty line, nothing to do */ mname = tline->text; smacro_deadman.tokens--; smacro_deadman.levels--; if (unlikely(smacro_deadman.tokens < 0 || smacro_deadman.levels < 0)) { if (unlikely(!smacro_deadman.triggered)) { nasm_nonfatal("interminable macro recursion"); smacro_deadman.triggered = true; } goto not_a_macro; } else if (tline->type == TOK_ID) { head = (SMacro *)hash_findix(&smacros, mname); } else if (tline->type == TOK_PREPROC_ID) { Context *ctx = get_ctx(mname, &mname); head = ctx ? (SMacro *)hash_findix(&ctx->localmac, mname) : NULL; } else { goto not_a_macro; } /* * We've hit an identifier of some sort. First check whether the * identifier is a single-line macro at all, then think about * checking for parameters if necessary. */ list_for_each(m, head) { if (!mstrcmp(m->name, mname, m->casesense)) break; } if (!m) { goto not_a_macro; } /* Parse parameters, if applicable */ params = NULL; nparam = 0; if (m->nparam == 0) { /* * Simple case: the macro is parameterless. * Nothing to parse; the expansion code will * drop the macro name token. */ } else { /* * Complicated case: at least one macro with this name * exists and takes parameters. We must find the * parameters in the call, count them, find the SMacro * that corresponds to that form of the macro call, and * substitute for the parameters when we expand. What a * pain. */ Token **phead, **pep; int paren = 1; int white = 0; int brackets = 0; bool bracketed = false; bool bad_bracket = false; unsigned int sparam = PARAM_DELTA; tline = tline->next; while (tok_type_(tline, TOK_WHITESPACE)) { tline = tline->next; } if (!tok_is_(tline, "(")) { /* * This macro wasn't called with parameters: ignore * the call. (Behaviour borrowed from gnu cpp.) */ goto not_a_macro; } paren = 1; nparam = 0; nasm_newn(params, sparam); phead = pep = ¶ms[0]; *pep = NULL; while (paren) { bool skip; char ch; tline = tline->next; if (!tline) { nasm_nonfatal("macro call expects terminating `)'"); goto not_a_macro; } ch = 0; skip = false; switch (tline->type) { case TOK_OTHER: if (!tline->text[1]) ch = tline->text[0]; break; case TOK_WHITESPACE: if (brackets || *phead) white++; /* Keep interior whitespace */ skip = true; break; default: break; } switch (ch) { case ',': if (!brackets) { if (++nparam >= sparam) { sparam += PARAM_DELTA; params = nasm_realloc(params, sparam * sizeof *params); } pep = ¶ms[nparam]; *pep = NULL; bracketed = false; skip = true; } break; case '{': if (!bracketed) { bracketed = !*phead; skip = true; } brackets++; break; case '}': if (brackets > 0) { if (!--brackets) skip = bracketed; } break; case '(': if (!brackets) paren++; break; case ')': if (!brackets) { paren--; if (!paren) { skip = true; /* Count the final argument */ nparam++; } } break; default: break; /* Normal token */ } if (!skip) { Token *t; bad_bracket |= bracketed && !brackets; if (white) { *pep = t = new_Token(NULL, TOK_WHITESPACE, NULL, 0); pep = &t->next; white = 0; } *pep = t = dup_Token(NULL, tline); pep = &t->next; white = 0; } } /* * Look for a macro matching in both name and parameter count. * We already know any matches cannot be anywhere before the * current position of "m", so there is no reason to * backtrack. */ while (1) { if (!m) { /*! *!macro-params-single [on] single-line macro calls with wrong parameter count *! warns about \i{single-line macros} being invoked *! with the wrong number of parameters. */ nasm_warn(WARN_MACRO_PARAMS_SINGLE, "single-line macro `%s' exists, " "but not taking %d parameter%s", mname, nparam, (nparam == 1) ? "" : "s"); goto not_a_macro; } if (m->nparam == nparam && !mstrcmp(m->name, mname, m->casesense)) break; /* It's good */ m = m->next; } } if (m->in_progress) goto not_a_macro; /* Expand each parameter */ m->in_progress = true; if (m->eval_param) { for (i = 0; i < nparam; i++) { if (m->eval_param[i]) { /* Evaluate this parameter as a number */ struct ppscan pps; struct tokenval tokval; expr *evalresult; Token *eval_param; pps.tptr = eval_param = expand_smacro_noreset(params[i]); pps.ntokens = -1; tokval.t_type = TOKEN_INVALID; evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL); free_tlist(eval_param); params[i] = NULL; if (!evalresult) { /* Nothing meaningful to do */ } else if (tokval.t_type) { nasm_nonfatal("invalid expression in parameter %d of macro `%s'", i, m->name); } else if (!is_simple(evalresult)) { nasm_nonfatal("non-constant expression in parameter %d of macro `%s'", i, m->name); } else { params[i] = make_tok_num(reloc_value(evalresult)); } } } } t = tline; tline = tline->next; /* Remove the macro call from the input */ t->next = NULL; /* Note: we own the expansion this returns. */ t = m->expand(m, params, nparam); tup = NULL; ttail = NULL; /* Pointer to the last token of the expansion */ while (t) { enum pp_token_type type = t->type; Token *tnext = t->next; Token **tp; switch (type) { case TOK_PREPROC_Q: case TOK_PREPROC_QQ: t->type = TOK_ID; nasm_free(t->text); t->text = nasm_strdup(type == TOK_PREPROC_QQ ? m->name : mname); t->len = nasm_last_string_len(); t->next = tline; break; case TOK_ID: case TOK_PREPROC_ID: /* * Chain this into the target line *before* expanding, * that way we pick up any arguments to the new macro call, * if applicable. */ t->next = tline; tp = &t; expand_one_smacro(&tp); if (t == tline) t = NULL; /* Null expansion */ break; default: if (is_smac_param(t->type)) { unsigned int param = smac_nparam(t->type); nasm_assert(!tup && param < nparam); delete_Token(t); t = NULL; tup = tnext; tnext = dup_tlist_reverse(params[param], NULL); } else { t->next = tline; } } if (t) { tline = t; if (!ttail) ttail = t; } if (tnext) { t = tnext; } else { t = tup; tup = NULL; } } **tpp = tline; if (ttail) *tpp = &ttail->next; m->in_progress = false; /* Don't do this until after expansion or we will clobber mname */ free_tlist(mstart); goto done; /* * No macro expansion needed; roll back to mstart (if necessary) * and then advance to the next input token. Note that this is * by far the common case! */ not_a_macro: *tpp = &mstart->next; m = NULL; done: smacro_deadman.levels++; if (unlikely(params)) free_tlist_array(params, nparam); return m; } /* * Expand all single-line macro calls made in the given line. * Return the expanded version of the line. The original is deemed * to be destroyed in the process. (In reality we'll just move * Tokens from input to output a lot of the time, rather than * actually bothering to destroy and replicate.) */ static Token *expand_smacro(Token *tline) { smacro_deadman.tokens = nasm_limit[LIMIT_MACRO_TOKENS]; smacro_deadman.levels = nasm_limit[LIMIT_MACRO_LEVELS]; smacro_deadman.triggered = false; return expand_smacro_noreset(tline); } static Token *expand_smacro_noreset(Token * tline) { Token *t, **tail, *thead; Token *org_tline = tline; bool expanded; /* * Trick: we should avoid changing the start token pointer since it can * be contained in "next" field of other token. Because of this * we allocate a copy of first token and work with it; at the end of * routine we copy it back */ if (org_tline) { tline = new_Token(org_tline->next, org_tline->type, org_tline->text, 0); nasm_free(org_tline->text); org_tline->text = NULL; } /* * Pretend that we always end up doing expansion on the first pass; * that way %+ get processed. However, if we process %+ before the * first pass, we end up with things like MACRO %+ TAIL trying to * look up the macro "MACROTAIL", which we don't want. */ expanded = true; thead = tline; while (true) { static const struct tokseq_match tmatch[] = { { PP_CONCAT_MASK(TOK_ID) | PP_CONCAT_MASK(TOK_PREPROC_ID), /* head */ PP_CONCAT_MASK(TOK_ID) | PP_CONCAT_MASK(TOK_PREPROC_ID) | PP_CONCAT_MASK(TOK_NUMBER) /* tail */ } }; tail = &thead; while ((t = *tail)) /* main token loop */ expanded |= !!expand_one_smacro(&tail); if (!expanded) { tline = thead; break; /* Done! */ } /* * Now scan the entire line and look for successive TOK_IDs * that resulted after expansion (they can't be produced by * tokenize()). The successive TOK_IDs should be concatenated. * Also we look for %+ tokens and concatenate the tokens * before and after them (without white spaces in between). */ paste_tokens(&thead, tmatch, ARRAY_SIZE(tmatch), true); expanded = false; } if (org_tline) { if (thead) { *org_tline = *thead; /* since we just gave text to org_line, don't free it */ thead->text = NULL; delete_Token(thead); } else { /* * The expression expanded to empty line; * we can't return NULL because of the "trick" above. * Just set the line to a single WHITESPACE token. */ memset(org_tline, 0, sizeof(*org_tline)); org_tline->text = NULL; org_tline->type = TOK_WHITESPACE; } thead = org_tline; } return thead; } /* * Similar to expand_smacro but used exclusively with macro identifiers * right before they are fetched in. The reason is that there can be * identifiers consisting of several subparts. We consider that if there * are more than one element forming the name, user wants a expansion, * otherwise it will be left as-is. Example: * * %define %$abc cde * * the identifier %$abc will be left as-is so that the handler for %define * will suck it and define the corresponding value. Other case: * * %define _%$abc cde * * In this case user wants name to be expanded *before* %define starts * working, so we'll expand %$abc into something (if it has a value; * otherwise it will be left as-is) then concatenate all successive * PP_IDs into one. */ static Token *expand_id(Token * tline) { Token *cur, *oldnext = NULL; if (!tline || !tline->next) return tline; cur = tline; while (cur->next && (cur->next->type == TOK_ID || cur->next->type == TOK_PREPROC_ID || cur->next->type == TOK_NUMBER)) cur = cur->next; /* If identifier consists of just one token, don't expand */ if (cur == tline) return tline; if (cur) { oldnext = cur->next; /* Detach the tail past identifier */ cur->next = NULL; /* so that expand_smacro stops here */ } tline = expand_smacro(tline); if (cur) { /* expand_smacro possibly changhed tline; re-scan for EOL */ cur = tline; while (cur && cur->next) cur = cur->next; if (cur) cur->next = oldnext; } return tline; } /* * Determine whether the given line constitutes a multi-line macro * call, and return the MMacro structure called if so. Doesn't have * to check for an initial label - that's taken care of in * expand_mmacro - but must check numbers of parameters. Guaranteed * to be called with tline->type == TOK_ID, so the putative macro * name is easy to find. */ static MMacro *is_mmacro(Token * tline, Token *** params_array) { MMacro *head, *m; Token **params; int nparam; head = (MMacro *) hash_findix(&mmacros, tline->text); /* * Efficiency: first we see if any macro exists with the given * name. If not, we can return NULL immediately. _Then_ we * count the parameters, and then we look further along the * list if necessary to find the proper MMacro. */ list_for_each(m, head) if (!mstrcmp(m->name, tline->text, m->casesense)) break; if (!m) return NULL; /* * OK, we have a potential macro. Count and demarcate the * parameters. */ count_mmac_params(tline->next, &nparam, ¶ms); /* * So we know how many parameters we've got. Find the MMacro * structure that handles this number. */ while (m) { if (m->nparam_min <= nparam && (m->plus || nparam <= m->nparam_max)) { /* * This one is right. Just check if cycle removal * prohibits us using it before we actually celebrate... */ if (m->in_progress > m->max_depth) { if (m->max_depth > 0) { nasm_warn(WARN_OTHER, "reached maximum recursion depth of %i", m->max_depth); } nasm_free(params); return NULL; } /* * It's right, and we can use it. Add its default * parameters to the end of our list if necessary. */ if (m->defaults && nparam < m->nparam_min + m->ndefs) { params = nasm_realloc(params, ((m->nparam_min + m->ndefs + 1) * sizeof(*params))); while (nparam < m->nparam_min + m->ndefs) { params[nparam] = m->defaults[nparam - m->nparam_min]; nparam++; } } /* * If we've gone over the maximum parameter count (and * we're in Plus mode), ignore parameters beyond * nparam_max. */ if (m->plus && nparam > m->nparam_max) nparam = m->nparam_max; /* * Then terminate the parameter list, and leave. */ if (!params) { /* need this special case */ params = nasm_malloc(sizeof(*params)); nparam = 0; } params[nparam] = NULL; *params_array = params; return m; } /* * This one wasn't right: look for the next one with the * same name. */ list_for_each(m, m->next) if (!mstrcmp(m->name, tline->text, m->casesense)) break; } /* * After all that, we didn't find one with the right number of * parameters. Issue a warning, and fail to expand the macro. *! *!macro-params-multi [on] multi-line macro calls with wrong parameter count *! warns about \i{multi-line macros} being invoked *! with the wrong number of parameters. See \k{mlmacover} for an *! example of why you might want to disable this warning. */ nasm_warn(WARN_MACRO_PARAMS_MULTI, "multi-line macro `%s' exists, but not taking %d parameter%s", tline->text, nparam, (nparam == 1) ? "" : "s"); nasm_free(params); return NULL; } /* * Save MMacro invocation specific fields in * preparation for a recursive macro expansion */ static void push_mmacro(MMacro *m) { MMacroInvocation *i; i = nasm_malloc(sizeof(MMacroInvocation)); i->prev = m->prev; i->params = m->params; i->iline = m->iline; i->nparam = m->nparam; i->rotate = m->rotate; i->paramlen = m->paramlen; i->unique = m->unique; i->condcnt = m->condcnt; m->prev = i; } /* * Restore MMacro invocation specific fields that were * saved during a previous recursive macro expansion */ static void pop_mmacro(MMacro *m) { MMacroInvocation *i; if (m->prev) { i = m->prev; m->prev = i->prev; m->params = i->params; m->iline = i->iline; m->nparam = i->nparam; m->rotate = i->rotate; m->paramlen = i->paramlen; m->unique = i->unique; m->condcnt = i->condcnt; nasm_free(i); } } /* * Expand the multi-line macro call made by the given line, if * there is one to be expanded. If there is, push the expansion on * istk->expansion and return 1. Otherwise return 0. */ static int expand_mmacro(Token * tline) { Token *startline = tline; Token *label = NULL; int dont_prepend = 0; Token **params, *t, *tt; MMacro *m; Line *l, *ll; int i, nparam, *paramlen; const char *mname; t = tline; skip_white_(t); /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */ if (!tok_type_(t, TOK_ID) && !tok_type_(t, TOK_PREPROC_ID)) return 0; m = is_mmacro(t, ¶ms); if (m) { mname = t->text; } else { Token *last; /* * We have an id which isn't a macro call. We'll assume * it might be a label; we'll also check to see if a * colon follows it. Then, if there's another id after * that lot, we'll check it again for macro-hood. */ label = last = t; t = t->next; if (tok_type_(t, TOK_WHITESPACE)) last = t, t = t->next; if (tok_is_(t, ":")) { dont_prepend = 1; last = t, t = t->next; if (tok_type_(t, TOK_WHITESPACE)) last = t, t = t->next; } if (!tok_type_(t, TOK_ID) || !(m = is_mmacro(t, ¶ms))) return 0; last->next = NULL; mname = t->text; tline = t; } /* * Fix up the parameters: this involves stripping leading and * trailing whitespace, then stripping braces if they are * present. */ for (nparam = 0; params[nparam]; nparam++) ; paramlen = nparam ? nasm_malloc(nparam * sizeof(*paramlen)) : NULL; for (i = 0; params[i]; i++) { int brace = 0; int comma = (!m->plus || i < nparam - 1); t = params[i]; skip_white_(t); if (tok_is_(t, "{")) t = t->next, brace++, comma = false; params[i] = t; paramlen[i] = 0; while (t) { if (comma && t->type == TOK_OTHER && !strcmp(t->text, ",")) break; /* ... because we have hit a comma */ if (comma && t->type == TOK_WHITESPACE && tok_is_(t->next, ",")) break; /* ... or a space then a comma */ if (brace && t->type == TOK_OTHER) { if (t->text[0] == '{') brace++; /* ... or a nested opening brace */ else if (t->text[0] == '}') if (!--brace) break; /* ... or a brace */ } t = t->next; paramlen[i]++; } if (brace) nasm_nonfatal("macro params should be enclosed in braces"); } /* * OK, we have a MMacro structure together with a set of * parameters. We must now go through the expansion and push * copies of each Line on to istk->expansion. Substitution of * parameter tokens and macro-local tokens doesn't get done * until the single-line macro substitution process; this is * because delaying them allows us to change the semantics * later through %rotate. * * First, push an end marker on to istk->expansion, mark this * macro as in progress, and set up its invocation-specific * variables. */ ll = nasm_malloc(sizeof(Line)); ll->next = istk->expansion; ll->finishes = m; ll->first = NULL; istk->expansion = ll; /* * Save the previous MMacro expansion in the case of * macro recursion */ if (m->max_depth && m->in_progress) push_mmacro(m); m->in_progress ++; m->params = params; m->iline = tline; m->nparam = nparam; m->rotate = 0; m->paramlen = paramlen; m->unique = unique++; m->lineno = 0; m->condcnt = 0; m->next_active = istk->mstk; istk->mstk = m; list_for_each(l, m->expansion) { Token **tail; ll = nasm_malloc(sizeof(Line)); ll->finishes = NULL; ll->next = istk->expansion; istk->expansion = ll; tail = &ll->first; list_for_each(t, l->first) { Token *x = t; switch (t->type) { case TOK_PREPROC_Q: tt = *tail = new_Token(NULL, TOK_ID, mname, 0); break; case TOK_PREPROC_QQ: tt = *tail = new_Token(NULL, TOK_ID, m->name, 0); break; case TOK_PREPROC_ID: if (t->text[1] == '0' && t->text[2] == '0') { dont_prepend = -1; x = label; if (!x) continue; } /* fall through */ default: tt = *tail = dup_Token(NULL, x); break; } tail = &tt->next; } *tail = NULL; } /* * If we had a label, push it on as the first line of * the macro expansion. */ if (label) { if (dont_prepend < 0) free_tlist(startline); else { nasm_new(ll); ll->finishes = NULL; ll->next = istk->expansion; istk->expansion = ll; ll->first = startline; if (!dont_prepend) { while (label->next) label = label->next; label->next = tt = new_Token(NULL, TOK_OTHER, ":", 0); } } } lfmt->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO, 0); return 1; } /* * This function adds macro names to error messages, and suppresses * them if necessary. */ static void pp_verror(errflags severity, const char *fmt, va_list arg) { /* * If we're in a dead branch of IF or something like it, ignore the error. * However, because %else etc are evaluated in the state context * of the previous branch, errors might get lost: * %if 0 ... %else trailing garbage ... %endif * So %else etc should set the ERR_PP_PRECOND flag. */ if ((severity & ERR_MASK) < ERR_FATAL && istk && istk->conds && ((severity & ERR_PP_PRECOND) ? istk->conds->state == COND_NEVER : !emitting(istk->conds->state))) return; /* This doesn't make sense with the macro stack unwinding */ if (0) { MMacro *mmac = NULL; int32_t delta = 0; /* get %macro name */ if (!(severity & ERR_NOFILE) && istk && istk->mstk) { mmac = istk->mstk; /* but %rep blocks should be skipped */ while (mmac && !mmac->name) mmac = mmac->next_active, delta++; } if (mmac) { char *buf; nasm_set_verror(real_verror); buf = nasm_vasprintf(fmt, arg); nasm_error(severity, "(%s:%"PRId32") %s", mmac->name, mmac->lineno - delta, buf); nasm_set_verror(pp_verror); nasm_free(buf); return; } } real_verror(severity, fmt, arg); } static Token * stdmac_file(const SMacro *s, Token **params, unsigned int nparams) { (void)s; (void)params; (void)nparams; return make_tok_qstr(src_get_fname()); } static Token * stdmac_line(const SMacro *s, Token **params, unsigned int nparams) { (void)s; (void)params; (void)nparams; return make_tok_num(src_get_linnum()); } static Token * stdmac_bits(const SMacro *s, Token **params, unsigned int nparams) { (void)s; (void)params; (void)nparams; return make_tok_num(globalbits); } static Token * stdmac_ptr(const SMacro *s, Token **params, unsigned int nparams) { const Token *t; static const Token ptr_word = { NULL, "word", 4, TOK_ID }; static const Token ptr_dword = { NULL, "dword", 5, TOK_ID }; static const Token ptr_qword = { NULL, "qword", 5, TOK_ID }; (void)s; (void)params; (void)nparams; switch (globalbits) { case 16: t = &ptr_word; break; case 32: t = &ptr_dword; break; case 64: t = &ptr_qword; break; default: panic(); } return dup_Token(NULL, t); } /* Add magic standard macros */ struct magic_macros { const char *name; int nparam; ExpandSMacro func; }; static const struct magic_macros magic_macros[] = { { "__FILE__", 0, stdmac_file }, { "__LINE__", 0, stdmac_line }, { "__BITS__", 0, stdmac_bits }, { "__PTR__", 0, stdmac_ptr }, { NULL, 0, NULL } }; static void pp_add_magic_stdmac(void) { const struct magic_macros *m; SMacro tmpl; nasm_zero(tmpl); for (m = magic_macros; m->name; m++) { tmpl.nparam = m->nparam; tmpl.expand = m->func; define_smacro(m->name, true, NULL, &tmpl); } } static void pp_reset(const char *file, enum preproc_mode mode, struct strlist *dep_list) { int apass; struct Include *inc; cstk = NULL; defining = NULL; nested_mac_count = 0; nested_rep_count = 0; init_macros(); unique = 0; deplist = dep_list; pp_mode = mode; if (!use_loaded) use_loaded = nasm_malloc(use_package_count * sizeof(bool)); memset(use_loaded, 0, use_package_count * sizeof(bool)); /* First set up the top level input file */ nasm_new(istk); istk->fp = nasm_open_read(file, NF_TEXT); src_set(0, file); istk->lineinc = 1; if (!istk->fp) nasm_fatalf(ERR_NOFILE, "unable to open input file `%s'", file); strlist_add(deplist, file); /* * Set up the stdmac packages as a virtual include file, * indicated by a null file pointer. */ nasm_new(inc); inc->next = istk; inc->fname = src_set_fname(NULL); inc->nolist = !list_option('b'); istk = inc; lfmt->uplevel(LIST_INCLUDE, 0); pp_add_magic_stdmac(); if (tasm_compatible_mode) pp_add_stdmac(nasm_stdmac_tasm); pp_add_stdmac(nasm_stdmac_nasm); pp_add_stdmac(nasm_stdmac_version); if (extrastdmac) pp_add_stdmac(extrastdmac); stdmacpos = stdmacros[0]; stdmacnext = &stdmacros[1]; do_predef = true; /* * Define the __PASS__ macro. This is defined here unlike all the * other builtins, because it is special -- it varies between * passes -- but there is really no particular reason to make it * magic. * * 0 = dependencies only * 1 = preparatory passes * 2 = final pass * 3 = preproces only */ switch (mode) { case PP_NORMAL: apass = pass_final() ? 2 : 1; break; case PP_DEPS: apass = 0; break; case PP_PREPROC: apass = 3; break; default: panic(); } define_smacro("__PASS__", true, make_tok_num(apass), NULL); } static void pp_init(void) { } /* * Get a line of tokens. If we popped the macro expansion/include stack, * we return a pointer to the dummy token tok_pop; at that point if * istk is NULL then we have reached end of input; */ static Token tok_pop; /* Dummy token placeholder */ static Token *pp_tokline(void) { Token *tline, *dtline; while (true) { /* * Fetch a tokenized line, either from the macro-expansion * buffer or from the input file. */ tline = NULL; while (istk->expansion && istk->expansion->finishes) { Line *l = istk->expansion; if (!l->finishes->name && l->finishes->in_progress > 1) { Line *ll; /* * This is a macro-end marker for a macro with no * name, which means it's not really a macro at all * but a %rep block, and the `in_progress' field is * more than 1, meaning that we still need to * repeat. (1 means the natural last repetition; 0 * means termination by %exitrep.) We have * therefore expanded up to the %endrep, and must * push the whole block on to the expansion buffer * again. We don't bother to remove the macro-end * marker: we'd only have to generate another one * if we did. */ l->finishes->in_progress--; list_for_each(l, l->finishes->expansion) { Token *t, *tt, **tail; ll = nasm_malloc(sizeof(Line)); ll->next = istk->expansion; ll->finishes = NULL; ll->first = NULL; tail = &ll->first; list_for_each(t, l->first) { if (t->text || t->type == TOK_WHITESPACE) { tt = *tail = dup_Token(NULL, t); tail = &tt->next; } } istk->expansion = ll; } } else { /* * Check whether a `%rep' was started and not ended * within this macro expansion. This can happen and * should be detected. It's a fatal error because * I'm too confused to work out how to recover * sensibly from it. */ if (defining) { if (defining->name) nasm_panic("defining with name in expansion"); else if (istk->mstk->name) nasm_fatal("`%%rep' without `%%endrep' within" " expansion of macro `%s'", istk->mstk->name); } /* * FIXME: investigate the relationship at this point between * istk->mstk and l->finishes */ { MMacro *m = istk->mstk; istk->mstk = m->next_active; if (m->name) { /* * This was a real macro call, not a %rep, and * therefore the parameter information needs to * be freed. */ if (m->prev) { pop_mmacro(m); l->finishes->in_progress --; } else { nasm_free(m->params); free_tlist(m->iline); nasm_free(m->paramlen); l->finishes->in_progress = 0; } } /* * FIXME It is incorrect to always free_mmacro here. * It leads to usage-after-free. * * https://bugzilla.nasm.us/show_bug.cgi?id=3392414 */ #if 0 else free_mmacro(m); #endif } istk->expansion = l->next; nasm_free(l); lfmt->downlevel(LIST_MACRO); return &tok_pop; } } do { /* until we get a line we can use */ char *line; if (istk->expansion) { /* from a macro expansion */ Line *l = istk->expansion; int32_t lineno; if (istk->mstk) { istk->mstk->lineno++; if (istk->mstk->fname) lineno = istk->mstk->lineno + istk->mstk->xline; else lineno = 0; /* Defined at init time or builtin */ } else { lineno = src_get_linnum(); } tline = l->first; istk->expansion = l->next; nasm_free(l); line = detoken(tline, false); if (!istk->nolist) lfmt->line(LIST_MACRO, lineno, line); nasm_free(line); } else if ((line = read_line())) { line = prepreproc(line); tline = tokenize(line); nasm_free(line); } else { /* * The current file has ended; work down the istk */ Include *i = istk; if (i->fp) fclose(i->fp); if (i->conds) { /* nasm_error can't be conditionally suppressed */ nasm_fatal("expected `%%endif' before end of file"); } /* only set line and file name if there's a next node */ if (i->next) src_set(i->lineno, i->fname); istk = i->next; lfmt->downlevel(LIST_INCLUDE); nasm_free(i); return &tok_pop; } } while (0); /* * We must expand MMacro parameters and MMacro-local labels * _before_ we plunge into directive processing, to cope * with things like `%define something %1' such as STRUC * uses. Unless we're _defining_ a MMacro, in which case * those tokens should be left alone to go into the * definition; and unless we're in a non-emitting * condition, in which case we don't want to meddle with * anything. */ if (!defining && !(istk->conds && !emitting(istk->conds->state)) && !(istk->mstk && !istk->mstk->in_progress)) { tline = expand_mmac_params(tline); } /* * Check the line to see if it's a preprocessor directive. */ if (do_directive(tline, &dtline) == DIRECTIVE_FOUND) { if (dtline) return dtline; } else if (defining) { /* * We're defining a multi-line macro. We emit nothing * at all, and just * shove the tokenized line on to the macro definition. */ Line *l = nasm_malloc(sizeof(Line)); l->next = defining->expansion; l->first = tline; l->finishes = NULL; defining->expansion = l; } else if (istk->conds && !emitting(istk->conds->state)) { /* * We're in a non-emitting branch of a condition block. * Emit nothing at all, not even a blank line: when we * emerge from the condition we'll give a line-number * directive so we keep our place correctly. */ free_tlist(tline); } else if (istk->mstk && !istk->mstk->in_progress) { /* * We're in a %rep block which has been terminated, so * we're walking through to the %endrep without * emitting anything. Emit nothing at all, not even a * blank line: when we emerge from the %rep block we'll * give a line-number directive so we keep our place * correctly. */ free_tlist(tline); } else { tline = expand_smacro(tline); if (!expand_mmacro(tline)) return tline; } } } static char *pp_getline(void) { char *line = NULL; Token *tline; real_verror = nasm_set_verror(pp_verror); while (true) { tline = pp_tokline(); if (tline == &tok_pop) { /* * We popped the macro/include stack. If istk is empty, * we are at end of input, otherwise just loop back. */ if (!istk) break; } else { /* * De-tokenize the line and emit it. */ line = detoken(tline, true); free_tlist(tline); break; } } if (list_option('e') && !istk->nolist && line && line[0]) { char *buf = nasm_strcat(" ;;; ", line); lfmt->line(LIST_MACRO, -1, buf); nasm_free(buf); } nasm_set_verror(real_verror); return line; } static void pp_cleanup_pass(void) { real_verror = nasm_set_verror(pp_verror); if (defining) { if (defining->name) { nasm_nonfatal("end of file while still defining macro `%s'", defining->name); } else { nasm_nonfatal("end of file while still in %%rep"); } free_mmacro(defining); defining = NULL; } nasm_set_verror(real_verror); while (cstk) ctx_pop(); free_macros(); while (istk) { Include *i = istk; istk = istk->next; fclose(i->fp); nasm_free(i); } while (cstk) ctx_pop(); src_set_fname(NULL); } static void pp_cleanup_session(void) { nasm_free(use_loaded); free_llist(predef); predef = NULL; delete_Blocks(); freeTokens = NULL; ipath_list = NULL; } static void pp_include_path(struct strlist *list) { ipath_list = list; } static void pp_pre_include(char *fname) { Token *inc, *space, *name; Line *l; name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0); space = new_Token(name, TOK_WHITESPACE, NULL, 0); inc = new_Token(space, TOK_PREPROC_ID, "%include", 0); l = nasm_malloc(sizeof(Line)); l->next = predef; l->first = inc; l->finishes = NULL; predef = l; } static void pp_pre_define(char *definition) { Token *def, *space; Line *l; char *equals; real_verror = nasm_set_verror(pp_verror); equals = strchr(definition, '='); space = new_Token(NULL, TOK_WHITESPACE, NULL, 0); def = new_Token(space, TOK_PREPROC_ID, "%define", 0); if (equals) *equals = ' '; space->next = tokenize(definition); if (equals) *equals = '='; if (space->next->type != TOK_PREPROC_ID && space->next->type != TOK_ID) nasm_warn(WARN_OTHER, "pre-defining non ID `%s\'\n", definition); l = nasm_malloc(sizeof(Line)); l->next = predef; l->first = def; l->finishes = NULL; predef = l; nasm_set_verror(real_verror); } static void pp_pre_undefine(char *definition) { Token *def, *space; Line *l; space = new_Token(NULL, TOK_WHITESPACE, NULL, 0); def = new_Token(space, TOK_PREPROC_ID, "%undef", 0); space->next = tokenize(definition); l = nasm_malloc(sizeof(Line)); l->next = predef; l->first = def; l->finishes = NULL; predef = l; } /* Insert an early preprocessor command that doesn't need special handling */ static void pp_pre_command(const char *what, char *string) { char *cmd; Token *def, *space; Line *l; def = tokenize(string); if (what) { cmd = nasm_strcat(what[0] == '%' ? "" : "%", what); space = new_Token(def, TOK_WHITESPACE, NULL, 0); def = new_Token(space, TOK_PREPROC_ID, cmd, 0); } l = nasm_malloc(sizeof(Line)); l->next = predef; l->first = def; l->finishes = NULL; predef = l; } static void pp_add_stdmac(macros_t *macros) { macros_t **mp; /* Find the end of the list and avoid duplicates */ for (mp = stdmacros; *mp; mp++) { if (*mp == macros) return; /* Nothing to do */ } nasm_assert(mp < &stdmacros[ARRAY_SIZE(stdmacros)-1]); *mp = macros; } static void pp_extra_stdmac(macros_t *macros) { extrastdmac = macros; } static Token *make_tok_num(int64_t val) { char numbuf[32]; int len = snprintf(numbuf, sizeof(numbuf), "%"PRId64"", val); return new_Token(NULL, TOK_NUMBER, numbuf, len); } static Token *make_tok_qstr(const char *str) { Token *t = new_Token(NULL, TOK_STRING, NULL, 0); t->text = nasm_quote_cstr(str, &t->len); return t; } static void pp_list_one_macro(MMacro *m, errflags severity) { if (!m) return; /* We need to print the next_active list in reverse order */ pp_list_one_macro(m->next_active, severity); if (m->name && !m->nolist) { src_set(m->xline + m->lineno, m->fname); nasm_error(severity, "... from macro `%s' defined", m->name); } } static void pp_error_list_macros(errflags severity) { struct src_location saved; severity |= ERR_PP_LISTMACRO | ERR_NO_SEVERITY | ERR_HERE; saved = src_where(); if (istk) pp_list_one_macro(istk->mstk, severity); src_update(saved); } const struct preproc_ops nasmpp = { pp_init, pp_reset, pp_getline, pp_cleanup_pass, pp_cleanup_session, pp_extra_stdmac, pp_pre_define, pp_pre_undefine, pp_pre_include, pp_pre_command, pp_include_path, pp_error_list_macros, };