preproc.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2010 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 /*
  35  * preproc.c   macro preprocessor for the Netwide Assembler
  36  */
  37
  38 /* Typical flow of text through preproc
  39  *
  40  * pp_getline gets tokenized lines, either
  41  *
  42  *   from a macro expansion
  43  *
  44  * or
  45  *   {
  46  *   read_line  gets raw text from stdmacpos, or predef, or current input file
  47  *   tokenize   converts to tokens
  48  *   }
  49  *
  50  * expand_mmac_params is used to expand %1 etc., unless a macro is being
  51  * defined or a false conditional is being processed
  52  * (%0, %1, %+1, %-1, %%foo
  53  *
  54  * do_directive checks for directives
  55  *
  56  * expand_smacro is used to expand single line macros
  57  *
  58  * expand_mmacro is used to expand multi-line macros
  59  *
  60  * detoken is used to convert the line back to text
  61  */
  62
  63 #include "compiler.h"
  64
  65 #include <stdio.h>
  66 #include <stdarg.h>
  67 #include <stdlib.h>
  68 #include <stddef.h>
  69 #include <string.h>
  70 #include <ctype.h>
  71 #include <limits.h>
  72 #include <inttypes.h>
  73
  74 #include "nasm.h"
  75 #include "nasmlib.h"
  76 #include "preproc.h"
  77 #include "hashtbl.h"
  78 #include "quote.h"
  79 #include "stdscan.h"
  80 #include "eval.h"
  81 #include "tokens.h"
  82 #include "tables.h"
  83
  84 typedef struct SMacro SMacro;
  85 typedef struct MMacro MMacro;
  86 typedef struct MMacroInvocation MMacroInvocation;
  87 typedef struct Context Context;
  88 typedef struct Token Token;
  89 typedef struct Blocks Blocks;
  90 typedef struct Line Line;
  91 typedef struct Include Include;
  92 typedef struct Cond Cond;
  93 typedef struct IncPath IncPath;
  94
  95 /*
  96  * Note on the storage of both SMacro and MMacros: the hash table
  97  * indexes them case-insensitively, and we then have to go through a
  98  * linked list of potential case aliases (and, for MMacros, parameter
  99  * ranges); this is to preserve the matching semantics of the earlier
 100  * code.  If the number of case aliases for a specific macro is a
 101  * performance issue, you may want to reconsider your coding style.
 102  */
 103
 104 /*
 105  * Store the definition of a single-line macro.
 106  */
 107 struct SMacro {
 108     SMacro *next;
 109     char *name;
 110     bool casesense;
 111     bool in_progress;
 112     unsigned int nparam;
 113     Token *expansion;
 114 };
 115
 116 /*
 117  * Store the definition of a multi-line macro. This is also used to
 118  * store the interiors of `%rep...%endrep' blocks, which are
 119  * effectively self-re-invoking multi-line macros which simply
 120  * don't have a name or bother to appear in the hash tables. %rep
 121  * blocks are signified by having a NULL `name' field.
 122  *
 123  * In a MMacro describing a `%rep' block, the `in_progress' field
 124  * isn't merely boolean, but gives the number of repeats left to
 125  * run.
 126  *
 127  * The `next' field is used for storing MMacros in hash tables; the
 128  * `next_active' field is for stacking them on istk entries.
 129  *
 130  * When a MMacro is being expanded, `params', `iline', `nparam',
 131  * `paramlen', `rotate' and `unique' are local to the invocation.
 132  */
 133 struct MMacro {
 134     MMacro *next;
 135     MMacroInvocation *prev;     /* previous invocation */
 136     char *name;
 137     int nparam_min, nparam_max;
 138     bool casesense;
 139     bool plus;                  /* is the last parameter greedy? */
 140     bool nolist;                /* is this macro listing-inhibited? */
 141     int64_t in_progress;        /* is this macro currently being expanded? */
 142     int32_t max_depth;          /* maximum number of recursive expansions allowed */
 143     Token *dlist;               /* All defaults as one list */
 144     Token **defaults;           /* Parameter default pointers */
 145     int ndefs;                  /* number of default parameters */
 146     Line *expansion;
 147
 148     MMacro *next_active;
 149     MMacro *rep_nest;           /* used for nesting %rep */
 150     Token **params;             /* actual parameters */
 151     Token *iline;               /* invocation line */
 152     unsigned int nparam, rotate;
 153     int *paramlen;
 154     uint64_t unique;
 155     int lineno;                 /* Current line number on expansion */
 156     uint64_t condcnt;           /* number of if blocks... */
 157 };
 158
 159
 160 /* Store the definition of a multi-line macro, as defined in a
 161  * previous recursive macro expansion.
 162  */
 163 struct MMacroInvocation {
 164     MMacroInvocation *prev;     /* previous invocation */
 165     Token **params;             /* actual parameters */
 166     Token *iline;               /* invocation line */
 167     unsigned int nparam, rotate;
 168     int *paramlen;
 169     uint64_t unique;
 170     uint64_t condcnt;
 171 };
 172
 173
 174 /*
 175  * The context stack is composed of a linked list of these.
 176  */
 177 struct Context {
 178     Context *next;
 179     char *name;
 180     struct hash_table localmac;
 181     uint32_t number;
 182 };
 183
 184 /*
 185  * This is the internal form which we break input lines up into.
 186  * Typically stored in linked lists.
 187  *
 188  * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
 189  * necessarily used as-is, but is intended to denote the number of
 190  * the substituted parameter. So in the definition
 191  *
 192  *     %define a(x,y) ( (x) & ~(y) )
 193  *
 194  * the token representing `x' will have its type changed to
 195  * TOK_SMAC_PARAM, but the one representing `y' will be
 196  * TOK_SMAC_PARAM+1.
 197  *
 198  * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
 199  * which doesn't need quotes around it. Used in the pre-include
 200  * mechanism as an alternative to trying to find a sensible type of
 201  * quote to use on the filename we were passed.
 202  */
 203 enum pp_token_type {
 204     TOK_NONE = 0, TOK_WHITESPACE, TOK_COMMENT, TOK_ID,
 205     TOK_PREPROC_ID, TOK_STRING,
 206     TOK_NUMBER, TOK_FLOAT, TOK_SMAC_END, TOK_OTHER,
 207     TOK_INTERNAL_STRING,
 208     TOK_PREPROC_Q, TOK_PREPROC_QQ,
 209     TOK_PASTE,              /* %+ */
 210     TOK_INDIRECT,           /* %[...] */
 211     TOK_SMAC_PARAM,         /* MUST BE LAST IN THE LIST!!! */
 212     TOK_MAX = INT_MAX       /* Keep compiler from reducing the range */
 213 };
 214
 215 struct Token {
 216     Token *next;
 217     char *text;
 218     union {
 219         SMacro *mac;        /* associated macro for TOK_SMAC_END */
 220         size_t len;         /* scratch length field */
 221     } a;                    /* Auxiliary data */
 222     enum pp_token_type type;
 223 };
 224
 225 /*
 226  * Multi-line macro definitions are stored as a linked list of
 227  * these, which is essentially a container to allow several linked
 228  * lists of Tokens.
 229  *
 230  * Note that in this module, linked lists are treated as stacks
 231  * wherever possible. For this reason, Lines are _pushed_ on to the
 232  * `expansion' field in MMacro structures, so that the linked list,
 233  * if walked, would give the macro lines in reverse order; this
 234  * means that we can walk the list when expanding a macro, and thus
 235  * push the lines on to the `expansion' field in _istk_ in reverse
 236  * order (so that when popped back off they are in the right
 237  * order). It may seem cockeyed, and it relies on my design having
 238  * an even number of steps in, but it works...
 239  *
 240  * Some of these structures, rather than being actual lines, are
 241  * markers delimiting the end of the expansion of a given macro.
 242  * This is for use in the cycle-tracking and %rep-handling code.
 243  * Such structures have `finishes' non-NULL, and `first' NULL. All
 244  * others have `finishes' NULL, but `first' may still be NULL if
 245  * the line is blank.
 246  */
 247 struct Line {
 248     Line *next;
 249     MMacro *finishes;
 250     Token *first;
 251 };
 252
 253 /*
 254  * To handle an arbitrary level of file inclusion, we maintain a
 255  * stack (ie linked list) of these things.
 256  */
 257 struct Include {
 258     Include *next;
 259     FILE *fp;
 260     Cond *conds;
 261     Line *expansion;
 262     char *fname;
 263     int lineno, lineinc;
 264     MMacro *mstk;       /* stack of active macros/reps */
 265 };
 266
 267 /*
 268  * Include search path. This is simply a list of strings which get
 269  * prepended, in turn, to the name of an include file, in an
 270  * attempt to find the file if it's not in the current directory.
 271  */
 272 struct IncPath {
 273     IncPath *next;
 274     char *path;
 275 };
 276
 277 /*
 278  * Conditional assembly: we maintain a separate stack of these for
 279  * each level of file inclusion. (The only reason we keep the
 280  * stacks separate is to ensure that a stray `%endif' in a file
 281  * included from within the true branch of a `%if' won't terminate
 282  * it and cause confusion: instead, rightly, it'll cause an error.)
 283  */
 284 struct Cond {
 285     Cond *next;
 286     int state;
 287 };
 288 enum {
 289     /*
 290      * These states are for use just after %if or %elif: IF_TRUE
 291      * means the condition has evaluated to truth so we are
 292      * currently emitting, whereas IF_FALSE means we are not
 293      * currently emitting but will start doing so if a %else comes
 294      * up. In these states, all directives are admissible: %elif,
 295      * %else and %endif. (And of course %if.)
 296      */
 297     COND_IF_TRUE, COND_IF_FALSE,
 298     /*
 299      * These states come up after a %else: ELSE_TRUE means we're
 300      * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
 301      * any %elif or %else will cause an error.
 302      */
 303     COND_ELSE_TRUE, COND_ELSE_FALSE,
 304     /*
 305      * These states mean that we're not emitting now, and also that
 306      * nothing until %endif will be emitted at all. COND_DONE is
 307      * used when we've had our moment of emission
 308      * and have now started seeing %elifs. COND_NEVER is used when
 309      * the condition construct in question is contained within a
 310      * non-emitting branch of a larger condition construct,
 311      * or if there is an error.
 312      */
 313     COND_DONE, COND_NEVER
 314 };
 315 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
 316
 317 /*
 318  * These defines are used as the possible return values for do_directive
 319  */
 320 #define NO_DIRECTIVE_FOUND  0
 321 #define DIRECTIVE_FOUND     1
 322
 323 /*
 324  * This define sets the upper limit for smacro and recursive mmacro
 325  * expansions
 326  */
 327 #define DEADMAN_LIMIT (1 << 20)
 328
 329 /*
 330  * Condition codes. Note that we use c_ prefix not C_ because C_ is
 331  * used in nasm.h for the "real" condition codes. At _this_ level,
 332  * we treat CXZ and ECXZ as condition codes, albeit non-invertible
 333  * ones, so we need a different enum...
 334  */
 335 static const char * const conditions[] = {
 336     "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
 337     "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
 338     "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
 339 };
 340 enum pp_conds {
 341     c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE,
 342     c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO,
 343     c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_RCXZ, c_S, c_Z,
 344     c_none = -1
 345 };
 346 static const enum pp_conds inverse_ccs[] = {
 347     c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE,
 348     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,
 349     c_Z, c_NO, c_NP, c_PO, c_PE, -1, c_NS, c_NZ
 350 };
 351
 352 /*
 353  * Directive names.
 354  */
 355 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
 356 static int is_condition(enum preproc_token arg)
 357 {
 358     return PP_IS_COND(arg) || (arg == PP_ELSE) || (arg == PP_ENDIF);
 359 }
 360
 361 /* For TASM compatibility we need to be able to recognise TASM compatible
 362  * conditional compilation directives. Using the NASM pre-processor does
 363  * not work, so we look for them specifically from the following list and
 364  * then jam in the equivalent NASM directive into the input stream.
 365  */
 366
 367 enum {
 368     TM_ARG, TM_ELIF, TM_ELSE, TM_ENDIF, TM_IF, TM_IFDEF, TM_IFDIFI,
 369     TM_IFNDEF, TM_INCLUDE, TM_LOCAL
 370 };
 371
 372 static const char * const tasm_directives[] = {
 373     "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
 374     "ifndef", "include", "local"
 375 };
 376
 377 static int StackSize = 4;
 378 static char *StackPointer = "ebp";
 379 static int ArgOffset = 8;
 380 static int LocalOffset = 0;
 381
 382 static Context *cstk;
 383 static Include *istk;
 384 static IncPath *ipath = NULL;
 385
 386 static int pass;            /* HACK: pass 0 = generate dependencies only */
 387 static StrList **dephead, **deptail; /* Dependency list */
 388
 389 static uint64_t unique;     /* unique identifier numbers */
 390
 391 static Line *predef = NULL;
 392 static bool do_predef;
 393
 394 static ListGen *list;
 395
 396 /*
 397  * The current set of multi-line macros we have defined.
 398  */
 399 static struct hash_table mmacros;
 400
 401 /*
 402  * The current set of single-line macros we have defined.
 403  */
 404 static struct hash_table smacros;
 405
 406 /*
 407  * The multi-line macro we are currently defining, or the %rep
 408  * block we are currently reading, if any.
 409  */
 410 static MMacro *defining;
 411
 412 static uint64_t nested_mac_count;
 413 static uint64_t nested_rep_count;
 414
 415 /*
 416  * The number of macro parameters to allocate space for at a time.
 417  */
 418 #define PARAM_DELTA 16
 419
 420 /*
 421  * The standard macro set: defined in macros.c in the array nasm_stdmac.
 422  * This gives our position in the macro set, when we're processing it.
 423  */
 424 static macros_t *stdmacpos;
 425
 426 /*
 427  * The extra standard macros that come from the object format, if
 428  * any.
 429  */
 430 static macros_t *extrastdmac = NULL;
 431 static bool any_extrastdmac;
 432
 433 /*
 434  * Tokens are allocated in blocks to improve speed
 435  */
 436 #define TOKEN_BLOCKSIZE 4096
 437 static Token *freeTokens = NULL;
 438 struct Blocks {
 439     Blocks *next;
 440     void *chunk;
 441 };
 442
 443 static Blocks blocks = { NULL, NULL };
 444
 445 /*
 446  * Forward declarations.
 447  */
 448 static Token *expand_mmac_params(Token * tline);
 449 static Token *expand_smacro(Token * tline);
 450 static Token *expand_id(Token * tline);
 451 static Context *get_ctx(const char *name, const char **namep,
 452                         bool all_contexts);
 453 static void make_tok_num(Token * tok, int64_t val);
 454 static void error(int severity, const char *fmt, ...);
 455 static void error_precond(int severity, const char *fmt, ...);
 456 static void *new_Block(size_t size);
 457 static void delete_Blocks(void);
 458 static Token *new_Token(Token * next, enum pp_token_type type,
 459                         const char *text, int txtlen);
 460 static Token *delete_Token(Token * t);
 461
 462 /*
 463  * Macros for safe checking of token pointers, avoid *(NULL)
 464  */
 465 #define tok_type_(x,t)  ((x) && (x)->type == (t))
 466 #define skip_white_(x)  if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
 467 #define tok_is_(x,v)    (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
 468 #define tok_isnt_(x,v)  ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
 469
 470 /*
 471  * Handle TASM specific directives, which do not contain a % in
 472  * front of them. We do it here because I could not find any other
 473  * place to do it for the moment, and it is a hack (ideally it would
 474  * be nice to be able to use the NASM pre-processor to do it).
 475  */
 476 static char *check_tasm_directive(char *line)
 477 {
 478     int32_t i, j, k, m, len;
 479     char *p, *q, *oldline, oldchar;
 480
 481     p = nasm_skip_spaces(line);
 482
 483     /* Binary search for the directive name */
 484     i = -1;
 485     j = elements(tasm_directives);
 486     q = nasm_skip_word(p);
 487     len = q - p;
 488     if (len) {
 489         oldchar = p[len];
 490         p[len] = 0;
 491         while (j - i > 1) {
 492             k = (j + i) / 2;
 493             m = nasm_stricmp(p, tasm_directives[k]);
 494             if (m == 0) {
 495                 /* We have found a directive, so jam a % in front of it
 496                  * so that NASM will then recognise it as one if it's own.
 497                  */
 498                 p[len] = oldchar;
 499                 len = strlen(p);
 500                 oldline = line;
 501                 line = nasm_malloc(len + 2);
 502                 line[0] = '%';
 503                 if (k == TM_IFDIFI) {
 504                     /*
 505                      * NASM does not recognise IFDIFI, so we convert
 506                      * it to %if 0. This is not used in NASM
 507                      * compatible code, but does need to parse for the
 508                      * TASM macro package.
 509                      */
 510                     strcpy(line + 1, "if 0");
 511                 } else {
 512                     memcpy(line + 1, p, len + 1);
 513                 }
 514                 nasm_free(oldline);
 515                 return line;
 516             } else if (m < 0) {
 517                 j = k;
 518             } else
 519                 i = k;
 520         }
 521         p[len] = oldchar;
 522     }
 523     return line;
 524 }
 525
 526 /*
 527  * The pre-preprocessing stage... This function translates line
 528  * number indications as they emerge from GNU cpp (`# lineno "file"
 529  * flags') into NASM preprocessor line number indications (`%line
 530  * lineno file').
 531  */
 532 static char *prepreproc(char *line)
 533 {
 534     int lineno, fnlen;
 535     char *fname, *oldline;
 536
 537     if (line[0] == '#' && line[1] == ' ') {
 538         oldline = line;
 539         fname = oldline + 2;
 540         lineno = atoi(fname);
 541         fname += strspn(fname, "0123456789 ");
 542         if (*fname == '"')
 543             fname++;
 544         fnlen = strcspn(fname, "\"");
 545         line = nasm_malloc(20 + fnlen);
 546         snprintf(line, 20 + fnlen, "%%line %d %.*s", lineno, fnlen, fname);
 547         nasm_free(oldline);
 548     }
 549     if (tasm_compatible_mode)
 550         return check_tasm_directive(line);
 551     return line;
 552 }
 553
 554 /*
 555  * Free a linked list of tokens.
 556  */
 557 static void free_tlist(Token * list)
 558 {
 559     while (list) {
 560         list = delete_Token(list);
 561     }
 562 }
 563
 564 /*
 565  * Free a linked list of lines.
 566  */
 567 static void free_llist(Line * list)
 568 {
 569     Line *l;
 570     while (list) {
 571         l = list;
 572         list = list->next;
 573         free_tlist(l->first);
 574         nasm_free(l);
 575     }
 576 }
 577
 578 /*
 579  * Free an MMacro
 580  */
 581 static void free_mmacro(MMacro * m)
 582 {
 583     nasm_free(m->name);
 584     free_tlist(m->dlist);
 585     nasm_free(m->defaults);
 586     free_llist(m->expansion);
 587     nasm_free(m);
 588 }
 589
 590 /*
 591  * Free all currently defined macros, and free the hash tables
 592  */
 593 static void free_smacro_table(struct hash_table *smt)
 594 {
 595     SMacro *s;
 596     const char *key;
 597     struct hash_tbl_node *it = NULL;
 598
 599     while ((s = hash_iterate(smt, &it, &key)) != NULL) {
 600         nasm_free((void *)key);
 601         while (s) {
 602             SMacro *ns = s->next;
 603             nasm_free(s->name);
 604             free_tlist(s->expansion);
 605             nasm_free(s);
 606             s = ns;
 607         }
 608     }
 609     hash_free(smt);
 610 }
 611
 612 static void free_mmacro_table(struct hash_table *mmt)
 613 {
 614     MMacro *m;
 615     const char *key;
 616     struct hash_tbl_node *it = NULL;
 617
 618     it = NULL;
 619     while ((m = hash_iterate(mmt, &it, &key)) != NULL) {
 620         nasm_free((void *)key);
 621         while (m) {
 622             MMacro *nm = m->next;
 623             free_mmacro(m);
 624             m = nm;
 625         }
 626     }
 627     hash_free(mmt);
 628 }
 629
 630 static void free_macros(void)
 631 {
 632     free_smacro_table(&smacros);
 633     free_mmacro_table(&mmacros);
 634 }
 635
 636 /*
 637  * Initialize the hash tables
 638  */
 639 static void init_macros(void)
 640 {
 641     hash_init(&smacros, HASH_LARGE);
 642     hash_init(&mmacros, HASH_LARGE);
 643 }
 644
 645 /*
 646  * Pop the context stack.
 647  */
 648 static void ctx_pop(void)
 649 {
 650     Context *c = cstk;
 651
 652     cstk = cstk->next;
 653     free_smacro_table(&c->localmac);
 654     nasm_free(c->name);
 655     nasm_free(c);
 656 }
 657
 658 /*
 659  * Search for a key in the hash index; adding it if necessary
 660  * (in which case we initialize the data pointer to NULL.)
 661  */
 662 static void **
 663 hash_findi_add(struct hash_table *hash, const char *str)
 664 {
 665     struct hash_insert hi;
 666     void **r;
 667     char *strx;
 668
 669     r = hash_findi(hash, str, &hi);
 670     if (r)
 671         return r;
 672
 673     strx = nasm_strdup(str);    /* Use a more efficient allocator here? */
 674     return hash_add(&hi, strx, NULL);
 675 }
 676
 677 /*
 678  * Like hash_findi, but returns the data element rather than a pointer
 679  * to it.  Used only when not adding a new element, hence no third
 680  * argument.
 681  */
 682 static void *
 683 hash_findix(struct hash_table *hash, const char *str)
 684 {
 685     void **p;
 686
 687     p = hash_findi(hash, str, NULL);
 688     return p ? *p : NULL;
 689 }
 690
 691 #define BUF_DELTA 512
 692 /*
 693  * Read a line from the top file in istk, handling multiple CR/LFs
 694  * at the end of the line read, and handling spurious ^Zs. Will
 695  * return lines from the standard macro set if this has not already
 696  * been done.
 697  */
 698 static char *read_line(void)
 699 {
 700     char *buffer, *p, *q;
 701     int bufsize, continued_count;
 702
 703     if (stdmacpos) {
 704         unsigned char c;
 705         const unsigned char *p = stdmacpos;
 706         char *ret, *q;
 707         size_t len = 0;
 708         while ((c = *p++)) {
 709             if (c >= 0x80)
 710                 len += pp_directives_len[c-0x80]+1;
 711             else
 712                 len++;
 713         }
 714         ret = nasm_malloc(len+1);
 715         q = ret;
 716         while ((c = *stdmacpos++)) {
 717             if (c >= 0x80) {
 718                 memcpy(q, pp_directives[c-0x80], pp_directives_len[c-0x80]);
 719                 q += pp_directives_len[c-0x80];
 720                 *q++ = ' ';
 721             } else {
 722                 *q++ = c;
 723             }
 724         }
 725         stdmacpos = p;
 726         *q = '\0';
 727
 728         if (!*stdmacpos) {
 729             /* This was the last of the standard macro chain... */
 730             stdmacpos = NULL;
 731             if (any_extrastdmac) {
 732                 stdmacpos = extrastdmac;
 733                 any_extrastdmac = false;
 734             } else if (do_predef) {
 735                 Line *pd, *l;
 736                 Token *head, **tail, *t;
 737
 738                 /*
 739                  * Nasty hack: here we push the contents of
 740                  * `predef' on to the top-level expansion stack,
 741                  * since this is the most convenient way to
 742                  * implement the pre-include and pre-define
 743                  * features.
 744                  */
 745                 for (pd = predef; pd; pd = pd->next) {
 746                     head = NULL;
 747                     tail = &head;
 748                     for (t = pd->first; t; t = t->next) {
 749                         *tail = new_Token(NULL, t->type, t->text, 0);
 750                         tail = &(*tail)->next;
 751                     }
 752                     l = nasm_malloc(sizeof(Line));
 753                     l->next = istk->expansion;
 754                     l->first = head;
 755                     l->finishes = NULL;
 756                     istk->expansion = l;
 757                 }
 758                 do_predef = false;
 759             }
 760         }
 761         return ret;
 762     }
 763
 764     bufsize = BUF_DELTA;
 765     buffer = nasm_malloc(BUF_DELTA);
 766     p = buffer;
 767     continued_count = 0;
 768     while (1) {
 769         q = fgets(p, bufsize - (p - buffer), istk->fp);
 770         if (!q)
 771             break;
 772         p += strlen(p);
 773         if (p > buffer && p[-1] == '\n') {
 774             /*
 775              * Convert backslash-CRLF line continuation sequences into
 776              * nothing at all (for DOS and Windows)
 777              */
 778             if (((p - 2) > buffer) && (p[-3] == '\\') && (p[-2] == '\r')) {
 779                 p -= 3;
 780                 *p = 0;
 781                 continued_count++;
 782             }
 783             /*
 784              * Also convert backslash-LF line continuation sequences into
 785              * nothing at all (for Unix)
 786              */
 787             else if (((p - 1) > buffer) && (p[-2] == '\\')) {
 788                 p -= 2;
 789                 *p = 0;
 790                 continued_count++;
 791             } else {
 792                 break;
 793             }
 794         }
 795         if (p - buffer > bufsize - 10) {
 796             int32_t offset = p - buffer;
 797             bufsize += BUF_DELTA;
 798             buffer = nasm_realloc(buffer, bufsize);
 799             p = buffer + offset;        /* prevent stale-pointer problems */
 800         }
 801     }
 802
 803     if (!q && p == buffer) {
 804         nasm_free(buffer);
 805         return NULL;
 806     }
 807
 808     src_set_linnum(src_get_linnum() + istk->lineinc +
 809                    (continued_count * istk->lineinc));
 810
 811     /*
 812      * Play safe: remove CRs as well as LFs, if any of either are
 813      * present at the end of the line.
 814      */
 815     while (--p >= buffer && (*p == '\n' || *p == '\r'))
 816         *p = '\0';
 817
 818     /*
 819      * Handle spurious ^Z, which may be inserted into source files
 820      * by some file transfer utilities.
 821      */
 822     buffer[strcspn(buffer, "\032")] = '\0';
 823
 824     list->line(LIST_READ, buffer);
 825
 826     return buffer;
 827 }
 828
 829 /*
 830  * Tokenize a line of text. This is a very simple process since we
 831  * don't need to parse the value out of e.g. numeric tokens: we
 832  * simply split one string into many.
 833  */
 834 static Token *tokenize(char *line)
 835 {
 836     char c, *p = line;
 837     enum pp_token_type type;
 838     Token *list = NULL;
 839     Token *t, **tail = &list;
 840
 841     while (*line) {
 842         p = line;
 843         if (*p == '%') {
 844             p++;
 845             if (*p == '+' && !nasm_isdigit(p[1])) {
 846                 p++;
 847                 type = TOK_PASTE;
 848             } else if (nasm_isdigit(*p) ||
 849                        ((*p == '-' || *p == '+') && nasm_isdigit(p[1]))) {
 850                 do {
 851                     p++;
 852                 }
 853                 while (nasm_isdigit(*p));
 854                 type = TOK_PREPROC_ID;
 855             } else if (*p == '{') {
 856                 p++;
 857                 while (*p && *p != '}') {
 858                     p[-1] = *p;
 859                     p++;
 860                 }
 861                 p[-1] = '\0';
 862                 if (*p)
 863                     p++;
 864                 type = TOK_PREPROC_ID;
 865             } else if (*p == '[') {
 866                 int lvl = 1;
 867                 line += 2;      /* Skip the leading %[ */
 868                 p++;
 869                 while (lvl && (c = *p++)) {
 870                     switch (c) {
 871                     case ']':
 872                         lvl--;
 873                         break;
 874                     case '%':
 875                         if (*p == '[')
 876                             lvl++;
 877                         break;
 878                     case '\'':
 879                     case '\"':
 880                     case '`':
 881                         p = nasm_skip_string(p)+1;
 882                         break;
 883                     default:
 884                         break;
 885                     }
 886                 }
 887                 p--;
 888                 if (*p)
 889                     *p++ = '\0';
 890                 if (lvl)
 891                     error(ERR_NONFATAL, "unterminated %[ construct");
 892                 type = TOK_INDIRECT;
 893             } else if (*p == '?') {
 894                 type = TOK_PREPROC_Q; /* %? */
 895                 p++;
 896                 if (*p == '?') {
 897                     type = TOK_PREPROC_QQ; /* %?? */
 898                     p++;
 899                 }
 900             } else if (isidchar(*p) ||
 901                        ((*p == '!' || *p == '%' || *p == '$') &&
 902                         isidchar(p[1]))) {
 903                 do {
 904                     p++;
 905                 }
 906                 while (isidchar(*p));
 907                 type = TOK_PREPROC_ID;
 908             } else {
 909                 type = TOK_OTHER;
 910                 if (*p == '%')
 911                     p++;
 912             }
 913         } else if (isidstart(*p) || (*p == '$' && isidstart(p[1]))) {
 914             type = TOK_ID;
 915             p++;
 916             while (*p && isidchar(*p))
 917                 p++;
 918         } else if (*p == '\'' || *p == '"' || *p == '`') {
 919             /*
 920              * A string token.
 921              */
 922             type = TOK_STRING;
 923             p = nasm_skip_string(p);
 924
 925             if (*p) {
 926                 p++;
 927             } else {
 928                 error(ERR_WARNING|ERR_PASS1, "unterminated string");
 929                 /* Handling unterminated strings by UNV */
 930                 /* type = -1; */
 931             }
 932         } else if (p[0] == '$' && p[1] == '$') {
 933             type = TOK_OTHER;   /* TOKEN_BASE */
 934             p += 2;
 935         } else if (isnumstart(*p)) {
 936             bool is_hex = false;
 937             bool is_float = false;
 938             bool has_e = false;
 939             char c, *r;
 940
 941             /*
 942              * A numeric token.
 943              */
 944
 945             if (*p == '$') {
 946                 p++;
 947                 is_hex = true;
 948             }
 949
 950             for (;;) {
 951                 c = *p++;
 952
 953                 if (!is_hex && (c == 'e' || c == 'E')) {
 954                     has_e = true;
 955                     if (*p == '+' || *p == '-') {
 956                         /*
 957                          * e can only be followed by +/- if it is either a
 958                          * prefixed hex number or a floating-point number
 959                          */
 960                         p++;
 961                         is_float = true;
 962                     }
 963                 } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') {
 964                     is_hex = true;
 965                 } else if (c == 'P' || c == 'p') {
 966                     is_float = true;
 967                     if (*p == '+' || *p == '-')
 968                         p++;
 969                 } else if (isnumchar(c) || c == '_')
 970                     ; /* just advance */
 971                 else if (c == '.') {
 972                     /*
 973                      * we need to deal with consequences of the legacy
 974                      * parser, like "1.nolist" being two tokens
 975                      * (TOK_NUMBER, TOK_ID) here; at least give it
 976                      * a shot for now.  In the future, we probably need
 977                      * a flex-based scanner with proper pattern matching
 978                      * to do it as well as it can be done.  Nothing in
 979                      * the world is going to help the person who wants
 980                      * 0x123.p16 interpreted as two tokens, though.
 981                      */
 982                     r = p;
 983                     while (*r == '_')
 984                         r++;
 985
 986                     if (nasm_isdigit(*r) || (is_hex && nasm_isxdigit(*r)) ||
 987                         (!is_hex && (*r == 'e' || *r == 'E')) ||
 988                         (*r == 'p' || *r == 'P')) {
 989                         p = r;
 990                         is_float = true;
 991                     } else
 992                         break;  /* Terminate the token */
 993                 } else
 994                     break;
 995             }
 996             p--;        /* Point to first character beyond number */
 997
 998             if (p == line+1 && *line == '$') {
 999                 type = TOK_OTHER; /* TOKEN_HERE */
1000             } else {
1001                 if (has_e && !is_hex) {
1002                     /* 1e13 is floating-point, but 1e13h is not */
1003                     is_float = true;
1004                 }
1005
1006                 type = is_float ? TOK_FLOAT : TOK_NUMBER;
1007             }
1008         } else if (nasm_isspace(*p)) {
1009             type = TOK_WHITESPACE;
1010             p = nasm_skip_spaces(p);
1011             /*
1012              * Whitespace just before end-of-line is discarded by
1013              * pretending it's a comment; whitespace just before a
1014              * comment gets lumped into the comment.
1015              */
1016             if (!*p || *p == ';') {
1017                 type = TOK_COMMENT;
1018                 while (*p)
1019                     p++;
1020             }
1021         } else if (*p == ';') {
1022             type = TOK_COMMENT;
1023             while (*p)
1024                 p++;
1025         } else {
1026             /*
1027              * Anything else is an operator of some kind. We check
1028              * for all the double-character operators (>>, <<, //,
1029              * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
1030              * else is a single-character operator.
1031              */
1032             type = TOK_OTHER;
1033             if ((p[0] == '>' && p[1] == '>') ||
1034                 (p[0] == '<' && p[1] == '<') ||
1035                 (p[0] == '/' && p[1] == '/') ||
1036                 (p[0] == '<' && p[1] == '=') ||
1037                 (p[0] == '>' && p[1] == '=') ||
1038                 (p[0] == '=' && p[1] == '=') ||
1039                 (p[0] == '!' && p[1] == '=') ||
1040                 (p[0] == '<' && p[1] == '>') ||
1041                 (p[0] == '&' && p[1] == '&') ||
1042                 (p[0] == '|' && p[1] == '|') ||
1043                 (p[0] == '^' && p[1] == '^')) {
1044                 p++;
1045             }
1046             p++;
1047         }
1048
1049         /* Handling unterminated string by UNV */
1050         /*if (type == -1)
1051           {
1052           *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
1053           t->text[p-line] = *line;
1054           tail = &t->next;
1055           }
1056           else */
1057         if (type != TOK_COMMENT) {
1058             *tail = t = new_Token(NULL, type, line, p - line);
1059             tail = &t->next;
1060         }
1061         line = p;
1062     }
1063     return list;
1064 }
1065
1066 /*
1067  * this function allocates a new managed block of memory and
1068  * returns a pointer to the block.  The managed blocks are
1069  * deleted only all at once by the delete_Blocks function.
1070  */
1071 static void *new_Block(size_t size)
1072 {
1073     Blocks *b = &blocks;
1074
1075     /* first, get to the end of the linked list */
1076     while (b->next)
1077         b = b->next;
1078     /* now allocate the requested chunk */
1079     b->chunk = nasm_malloc(size);
1080
1081     /* now allocate a new block for the next request */
1082     b->next = nasm_malloc(sizeof(Blocks));
1083     /* and initialize the contents of the new block */
1084     b->next->next = NULL;
1085     b->next->chunk = NULL;
1086     return b->chunk;
1087 }
1088
1089 /*
1090  * this function deletes all managed blocks of memory
1091  */
1092 static void delete_Blocks(void)
1093 {
1094     Blocks *a, *b = &blocks;
1095
1096     /*
1097      * keep in mind that the first block, pointed to by blocks
1098      * is a static and not dynamically allocated, so we don't
1099      * free it.
1100      */
1101     while (b) {
1102         if (b->chunk)
1103             nasm_free(b->chunk);
1104         a = b;
1105         b = b->next;
1106         if (a != &blocks)
1107             nasm_free(a);
1108     }
1109 }
1110
1111 /*
1112  *  this function creates a new Token and passes a pointer to it
1113  *  back to the caller.  It sets the type and text elements, and
1114  *  also the a.mac and next elements to NULL.
1115  */
1116 static Token *new_Token(Token * next, enum pp_token_type type,
1117                         const char *text, int txtlen)
1118 {
1119     Token *t;
1120     int i;
1121
1122     if (!freeTokens) {
1123         freeTokens = (Token *) new_Block(TOKEN_BLOCKSIZE * sizeof(Token));
1124         for (i = 0; i < TOKEN_BLOCKSIZE - 1; i++)
1125             freeTokens[i].next = &freeTokens[i + 1];
1126         freeTokens[i].next = NULL;
1127     }
1128     t = freeTokens;
1129     freeTokens = t->next;
1130     t->next = next;
1131     t->a.mac = NULL;
1132     t->type = type;
1133     if (type == TOK_WHITESPACE || !text) {
1134         t->text = NULL;
1135     } else {
1136         if (txtlen == 0)
1137             txtlen = strlen(text);
1138         t->text = nasm_malloc(txtlen+1);
1139         memcpy(t->text, text, txtlen);
1140         t->text[txtlen] = '\0';
1141     }
1142     return t;
1143 }
1144
1145 static Token *delete_Token(Token * t)
1146 {
1147     Token *next = t->next;
1148     nasm_free(t->text);
1149     t->next = freeTokens;
1150     freeTokens = t;
1151     return next;
1152 }
1153
1154 /*
1155  * Convert a line of tokens back into text.
1156  * If expand_locals is not zero, identifiers of the form "%$*xxx"
1157  * will be transformed into ..@ctxnum.xxx
1158  */
1159 static char *detoken(Token * tlist, bool expand_locals)
1160 {
1161     Token *t;
1162     int len;
1163     char *line, *p;
1164     const char *q;
1165
1166     len = 0;
1167     for (t = tlist; t; t = t->next) {
1168         if (t->type == TOK_PREPROC_ID && t->text[1] == '!') {
1169             char *p = getenv(t->text + 2);
1170             nasm_free(t->text);
1171             if (p)
1172                 t->text = nasm_strdup(p);
1173             else
1174                 t->text = NULL;
1175         }
1176         /* Expand local macros here and not during preprocessing */
1177         if (expand_locals &&
1178             t->type == TOK_PREPROC_ID && t->text &&
1179             t->text[0] == '%' && t->text[1] == '$') {
1180             const char *q;
1181             char *p;
1182             Context *ctx = get_ctx(t->text, &q, false);
1183             if (ctx) {
1184                 char buffer[40];
1185                 snprintf(buffer, sizeof(buffer), "..@%"PRIu32".", ctx->number);
1186                 p = nasm_strcat(buffer, q);
1187                 nasm_free(t->text);
1188                 t->text = p;
1189             }
1190         }
1191         if (t->type == TOK_WHITESPACE) {
1192             len++;
1193         } else if (t->text) {
1194             len += strlen(t->text);
1195         }
1196     }
1197     p = line = nasm_malloc(len + 1);
1198     for (t = tlist; t; t = t->next) {
1199         if (t->type == TOK_WHITESPACE) {
1200             *p++ = ' ';
1201         } else if (t->text) {
1202             q = t->text;
1203             while (*q)
1204                 *p++ = *q++;
1205         }
1206     }
1207     *p = '\0';
1208     return line;
1209 }
1210
1211 /*
1212  * A scanner, suitable for use by the expression evaluator, which
1213  * operates on a line of Tokens. Expects a pointer to a pointer to
1214  * the first token in the line to be passed in as its private_data
1215  * field.
1216  *
1217  * FIX: This really needs to be unified with stdscan.
1218  */
1219 static int ppscan(void *private_data, struct tokenval *tokval)
1220 {
1221     Token **tlineptr = private_data;
1222     Token *tline;
1223     char ourcopy[MAX_KEYWORD+1], *p, *r, *s;
1224
1225     do {
1226         tline = *tlineptr;
1227         *tlineptr = tline ? tline->next : NULL;
1228     }
1229     while (tline && (tline->type == TOK_WHITESPACE ||
1230                      tline->type == TOK_COMMENT));
1231
1232     if (!tline)
1233         return tokval->t_type = TOKEN_EOS;
1234
1235     tokval->t_charptr = tline->text;
1236
1237     if (tline->text[0] == '$' && !tline->text[1])
1238         return tokval->t_type = TOKEN_HERE;
1239     if (tline->text[0] == '$' && tline->text[1] == '$' && !tline->text[2])
1240         return tokval->t_type = TOKEN_BASE;
1241
1242     if (tline->type == TOK_ID) {
1243         p = tokval->t_charptr = tline->text;
1244         if (p[0] == '$') {
1245             tokval->t_charptr++;
1246             return tokval->t_type = TOKEN_ID;
1247         }
1248
1249         for (r = p, s = ourcopy; *r; r++) {
1250             if (r >= p+MAX_KEYWORD)
1251                 return tokval->t_type = TOKEN_ID; /* Not a keyword */
1252             *s++ = nasm_tolower(*r);
1253         }
1254         *s = '\0';
1255         /* right, so we have an identifier sitting in temp storage. now,
1256          * is it actually a register or instruction name, or what? */
1257         return nasm_token_hash(ourcopy, tokval);
1258     }
1259
1260     if (tline->type == TOK_NUMBER) {
1261         bool rn_error;
1262         tokval->t_integer = readnum(tline->text, &rn_error);
1263         tokval->t_charptr = tline->text;
1264         if (rn_error)
1265             return tokval->t_type = TOKEN_ERRNUM;
1266         else
1267             return tokval->t_type = TOKEN_NUM;
1268     }
1269
1270     if (tline->type == TOK_FLOAT) {
1271         return tokval->t_type = TOKEN_FLOAT;
1272     }
1273
1274     if (tline->type == TOK_STRING) {
1275         char bq, *ep;
1276
1277         bq = tline->text[0];
1278         tokval->t_charptr = tline->text;
1279         tokval->t_inttwo = nasm_unquote(tline->text, &ep);
1280
1281         if (ep[0] != bq || ep[1] != '\0')
1282             return tokval->t_type = TOKEN_ERRSTR;
1283         else
1284             return tokval->t_type = TOKEN_STR;
1285     }
1286
1287     if (tline->type == TOK_OTHER) {
1288         if (!strcmp(tline->text, "<<"))
1289             return tokval->t_type = TOKEN_SHL;
1290         if (!strcmp(tline->text, ">>"))
1291             return tokval->t_type = TOKEN_SHR;
1292         if (!strcmp(tline->text, "//"))
1293             return tokval->t_type = TOKEN_SDIV;
1294         if (!strcmp(tline->text, "%%"))
1295             return tokval->t_type = TOKEN_SMOD;
1296         if (!strcmp(tline->text, "=="))
1297             return tokval->t_type = TOKEN_EQ;
1298         if (!strcmp(tline->text, "<>"))
1299             return tokval->t_type = TOKEN_NE;
1300         if (!strcmp(tline->text, "!="))
1301             return tokval->t_type = TOKEN_NE;
1302         if (!strcmp(tline->text, "<="))
1303             return tokval->t_type = TOKEN_LE;
1304         if (!strcmp(tline->text, ">="))
1305             return tokval->t_type = TOKEN_GE;
1306         if (!strcmp(tline->text, "&&"))
1307             return tokval->t_type = TOKEN_DBL_AND;
1308         if (!strcmp(tline->text, "^^"))
1309             return tokval->t_type = TOKEN_DBL_XOR;
1310         if (!strcmp(tline->text, "||"))
1311             return tokval->t_type = TOKEN_DBL_OR;
1312     }
1313
1314     /*
1315      * We have no other options: just return the first character of
1316      * the token text.
1317      */
1318     return tokval->t_type = tline->text[0];
1319 }
1320
1321 /*
1322  * Compare a string to the name of an existing macro; this is a
1323  * simple wrapper which calls either strcmp or nasm_stricmp
1324  * depending on the value of the `casesense' parameter.
1325  */
1326 static int mstrcmp(const char *p, const char *q, bool casesense)
1327 {
1328     return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
1329 }
1330
1331 /*
1332  * Compare a string to the name of an existing macro; this is a
1333  * simple wrapper which calls either strcmp or nasm_stricmp
1334  * depending on the value of the `casesense' parameter.
1335  */
1336 static int mmemcmp(const char *p, const char *q, size_t l, bool casesense)
1337 {
1338     return casesense ? memcmp(p, q, l) : nasm_memicmp(p, q, l);
1339 }
1340
1341 /*
1342  * Return the Context structure associated with a %$ token. Return
1343  * NULL, having _already_ reported an error condition, if the
1344  * context stack isn't deep enough for the supplied number of $
1345  * signs.
1346  * If all_contexts == true, contexts that enclose current are
1347  * also scanned for such smacro, until it is found; if not -
1348  * only the context that directly results from the number of $'s
1349  * in variable's name.
1350  *
1351  * If "namep" is non-NULL, set it to the pointer to the macro name
1352  * tail, i.e. the part beyond %$...
1353  */
1354 static Context *get_ctx(const char *name, const char **namep,
1355                         bool all_contexts)
1356 {
1357     Context *ctx;
1358     SMacro *m;
1359     int i;
1360
1361     if (namep)
1362         *namep = name;
1363
1364     if (!name || name[0] != '%' || name[1] != '$')
1365         return NULL;
1366
1367     if (!cstk) {
1368         error(ERR_NONFATAL, "`%s': context stack is empty", name);
1369         return NULL;
1370     }
1371
1372     name += 2;
1373     ctx = cstk;
1374     i = 0;
1375     while (ctx && *name == '$') {
1376         name++;
1377         i++;
1378         ctx = ctx->next;
1379     }
1380     if (!ctx) {
1381         error(ERR_NONFATAL, "`%s': context stack is only"
1382               " %d level%s deep", name, i, (i == 1 ? "" : "s"));
1383         return NULL;
1384     }
1385
1386     if (namep)
1387         *namep = name;
1388
1389     if (!all_contexts)
1390         return ctx;
1391
1392     do {
1393         /* Search for this smacro in found context */
1394         m = hash_findix(&ctx->localmac, name);
1395         while (m) {
1396             if (!mstrcmp(m->name, name, m->casesense))
1397                 return ctx;
1398             m = m->next;
1399         }
1400         ctx = ctx->next;
1401     }
1402     while (ctx);
1403     return NULL;
1404 }
1405
1406 /*
1407  * Check to see if a file is already in a string list
1408  */
1409 static bool in_list(const StrList *list, const char *str)
1410 {
1411     while (list) {
1412         if (!strcmp(list->str, str))
1413             return true;
1414         list = list->next;
1415     }
1416     return false;
1417 }
1418
1419 /*
1420  * Open an include file. This routine must always return a valid
1421  * file pointer if it returns - it's responsible for throwing an
1422  * ERR_FATAL and bombing out completely if not. It should also try
1423  * the include path one by one until it finds the file or reaches
1424  * the end of the path.
1425  */
1426 static FILE *inc_fopen(const char *file, StrList **dhead, StrList ***dtail,
1427                        bool missing_ok)
1428 {
1429     FILE *fp;
1430     char *prefix = "";
1431     IncPath *ip = ipath;
1432     int len = strlen(file);
1433     size_t prefix_len = 0;
1434     StrList *sl;
1435
1436     while (1) {
1437         sl = nasm_malloc(prefix_len+len+1+sizeof sl->next);
1438         memcpy(sl->str, prefix, prefix_len);
1439         memcpy(sl->str+prefix_len, file, len+1);
1440         fp = fopen(sl->str, "r");
1441         if (fp && dhead && !in_list(*dhead, sl->str)) {
1442             sl->next = NULL;
1443             **dtail = sl;
1444             *dtail = &sl->next;
1445         } else {
1446             nasm_free(sl);
1447         }
1448         if (fp)
1449             return fp;
1450         if (!ip) {
1451             if (!missing_ok)
1452                 break;
1453             prefix = NULL;
1454         } else {
1455             prefix = ip->path;
1456             ip = ip->next;
1457         }
1458         if (prefix) {
1459             prefix_len = strlen(prefix);
1460         } else {
1461             /* -MG given and file not found */
1462             if (dhead && !in_list(*dhead, file)) {
1463                 sl = nasm_malloc(len+1+sizeof sl->next);
1464                 sl->next = NULL;
1465                 strcpy(sl->str, file);
1466                 **dtail = sl;
1467                 *dtail = &sl->next;
1468             }
1469             return NULL;
1470         }
1471     }
1472
1473     error(ERR_FATAL, "unable to open include file `%s'", file);
1474     return NULL;
1475 }
1476
1477 /*
1478  * Determine if we should warn on defining a single-line macro of
1479  * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1480  * return true if _any_ single-line macro of that name is defined.
1481  * Otherwise, will return true if a single-line macro with either
1482  * `nparam' or no parameters is defined.
1483  *
1484  * If a macro with precisely the right number of parameters is
1485  * defined, or nparam is -1, the address of the definition structure
1486  * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1487  * is NULL, no action will be taken regarding its contents, and no
1488  * error will occur.
1489  *
1490  * Note that this is also called with nparam zero to resolve
1491  * `ifdef'.
1492  *
1493  * If you already know which context macro belongs to, you can pass
1494  * the context pointer as first parameter; if you won't but name begins
1495  * with %$ the context will be automatically computed. If all_contexts
1496  * is true, macro will be searched in outer contexts as well.
1497  */
1498 static bool
1499 smacro_defined(Context * ctx, const char *name, int nparam, SMacro ** defn,
1500                bool nocase)
1501 {
1502     struct hash_table *smtbl;
1503     SMacro *m;
1504
1505     if (ctx) {
1506         smtbl = &ctx->localmac;
1507     } else if (name[0] == '%' && name[1] == '$') {
1508         if (cstk)
1509             ctx = get_ctx(name, &name, false);
1510         if (!ctx)
1511             return false;       /* got to return _something_ */
1512         smtbl = &ctx->localmac;
1513     } else {
1514         smtbl = &smacros;
1515     }
1516     m = (SMacro *) hash_findix(smtbl, name);
1517
1518     while (m) {
1519         if (!mstrcmp(m->name, name, m->casesense && nocase) &&
1520             (nparam <= 0 || m->nparam == 0 || nparam == (int) m->nparam)) {
1521             if (defn) {
1522                 if (nparam == (int) m->nparam || nparam == -1)
1523                     *defn = m;
1524                 else
1525                     *defn = NULL;
1526             }
1527             return true;
1528         }
1529         m = m->next;
1530     }
1531
1532     return false;
1533 }
1534
1535 /*
1536  * Count and mark off the parameters in a multi-line macro call.
1537  * This is called both from within the multi-line macro expansion
1538  * code, and also to mark off the default parameters when provided
1539  * in a %macro definition line.
1540  */
1541 static void count_mmac_params(Token * t, int *nparam, Token *** params)
1542 {
1543     int paramsize, brace;
1544
1545     *nparam = paramsize = 0;
1546     *params = NULL;
1547     while (t) {
1548         /* +1: we need space for the final NULL */
1549         if (*nparam+1 >= paramsize) {
1550             paramsize += PARAM_DELTA;
1551             *params = nasm_realloc(*params, sizeof(**params) * paramsize);
1552         }
1553         skip_white_(t);
1554         brace = false;
1555         if (tok_is_(t, "{"))
1556             brace = true;
1557         (*params)[(*nparam)++] = t;
1558         while (tok_isnt_(t, brace ? "}" : ","))
1559             t = t->next;
1560         if (t) {                /* got a comma/brace */
1561             t = t->next;
1562             if (brace) {
1563                 /*
1564                  * Now we've found the closing brace, look further
1565                  * for the comma.
1566                  */
1567                 skip_white_(t);
1568                 if (tok_isnt_(t, ",")) {
1569                     error(ERR_NONFATAL,
1570                           "braces do not enclose all of macro parameter");
1571                     while (tok_isnt_(t, ","))
1572                         t = t->next;
1573                 }
1574                 if (t)
1575                     t = t->next;        /* eat the comma */
1576             }
1577         }
1578     }
1579 }
1580
1581 /*
1582  * Determine whether one of the various `if' conditions is true or
1583  * not.
1584  *
1585  * We must free the tline we get passed.
1586  */
1587 static bool if_condition(Token * tline, enum preproc_token ct)
1588 {
1589     enum pp_conditional i = PP_COND(ct);
1590     bool j;
1591     Token *t, *tt, **tptr, *origline;
1592     struct tokenval tokval;
1593     expr *evalresult;
1594     enum pp_token_type needtype;
1595
1596     origline = tline;
1597
1598     switch (i) {
1599     case PPC_IFCTX:
1600         j = false;              /* have we matched yet? */
1601         while (true) {
1602             skip_white_(tline);
1603             if (!tline)
1604                 break;
1605             if (tline->type != TOK_ID) {
1606                 error(ERR_NONFATAL,
1607                       "`%s' expects context identifiers", pp_directives[ct]);
1608                 free_tlist(origline);
1609                 return -1;
1610             }
1611             if (cstk && cstk->name && !nasm_stricmp(tline->text, cstk->name))
1612                 j = true;
1613             tline = tline->next;
1614         }
1615         break;
1616
1617     case PPC_IFDEF:
1618         j = false;              /* have we matched yet? */
1619         while (tline) {
1620             skip_white_(tline);
1621             if (!tline || (tline->type != TOK_ID &&
1622                            (tline->type != TOK_PREPROC_ID ||
1623                             tline->text[1] != '$'))) {
1624                 error(ERR_NONFATAL,
1625                       "`%s' expects macro identifiers", pp_directives[ct]);
1626                 goto fail;
1627             }
1628             if (smacro_defined(NULL, tline->text, 0, NULL, true))
1629                 j = true;
1630             tline = tline->next;
1631         }
1632         break;
1633
1634     case PPC_IFIDN:
1635     case PPC_IFIDNI:
1636         tline = expand_smacro(tline);
1637         t = tt = tline;
1638         while (tok_isnt_(tt, ","))
1639             tt = tt->next;
1640         if (!tt) {
1641             error(ERR_NONFATAL,
1642                   "`%s' expects two comma-separated arguments",
1643                   pp_directives[ct]);
1644             goto fail;
1645         }
1646         tt = tt->next;
1647         j = true;               /* assume equality unless proved not */
1648         while ((t->type != TOK_OTHER || strcmp(t->text, ",")) && tt) {
1649             if (tt->type == TOK_OTHER && !strcmp(tt->text, ",")) {
1650                 error(ERR_NONFATAL, "`%s': more than one comma on line",
1651                       pp_directives[ct]);
1652                 goto fail;
1653             }
1654             if (t->type == TOK_WHITESPACE) {
1655                 t = t->next;
1656                 continue;
1657             }
1658             if (tt->type == TOK_WHITESPACE) {
1659                 tt = tt->next;
1660                 continue;
1661             }
1662             if (tt->type != t->type) {
1663                 j = false;      /* found mismatching tokens */
1664                 break;
1665             }
1666             /* When comparing strings, need to unquote them first */
1667             if (t->type == TOK_STRING) {
1668                 size_t l1 = nasm_unquote(t->text, NULL);
1669                 size_t l2 = nasm_unquote(tt->text, NULL);
1670
1671                 if (l1 != l2) {
1672                     j = false;
1673                     break;
1674                 }
1675                 if (mmemcmp(t->text, tt->text, l1, i == PPC_IFIDN)) {
1676                     j = false;
1677                     break;
1678                 }
1679             } else if (mstrcmp(tt->text, t->text, i == PPC_IFIDN) != 0) {
1680                 j = false;      /* found mismatching tokens */
1681                 break;
1682             }
1683
1684             t = t->next;
1685             tt = tt->next;
1686         }
1687         if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
1688             j = false;          /* trailing gunk on one end or other */
1689         break;
1690
1691     case PPC_IFMACRO:
1692     {
1693         bool found = false;
1694         MMacro searching, *mmac;
1695
1696         skip_white_(tline);
1697         tline = expand_id(tline);
1698         if (!tok_type_(tline, TOK_ID)) {
1699             error(ERR_NONFATAL,
1700                   "`%s' expects a macro name", pp_directives[ct]);
1701             goto fail;
1702         }
1703         searching.name = nasm_strdup(tline->text);
1704         searching.casesense = true;
1705         searching.plus = false;
1706         searching.nolist = false;
1707         searching.in_progress = 0;
1708         searching.max_depth = 0;
1709         searching.rep_nest = NULL;
1710         searching.nparam_min = 0;
1711         searching.nparam_max = INT_MAX;
1712         tline = expand_smacro(tline->next);
1713         skip_white_(tline);
1714         if (!tline) {
1715         } else if (!tok_type_(tline, TOK_NUMBER)) {
1716             error(ERR_NONFATAL,
1717                   "`%s' expects a parameter count or nothing",
1718                   pp_directives[ct]);
1719         } else {
1720             searching.nparam_min = searching.nparam_max =
1721                 readnum(tline->text, &j);
1722             if (j)
1723                 error(ERR_NONFATAL,
1724                       "unable to parse parameter count `%s'",
1725                       tline->text);
1726         }
1727         if (tline && tok_is_(tline->next, "-")) {
1728             tline = tline->next->next;
1729             if (tok_is_(tline, "*"))
1730                 searching.nparam_max = INT_MAX;
1731             else if (!tok_type_(tline, TOK_NUMBER))
1732                 error(ERR_NONFATAL,
1733                       "`%s' expects a parameter count after `-'",
1734                       pp_directives[ct]);
1735             else {
1736                 searching.nparam_max = readnum(tline->text, &j);
1737                 if (j)
1738                     error(ERR_NONFATAL,
1739                           "unable to parse parameter count `%s'",
1740                           tline->text);
1741                 if (searching.nparam_min > searching.nparam_max)
1742                     error(ERR_NONFATAL,
1743                           "minimum parameter count exceeds maximum");
1744             }
1745         }
1746         if (tline && tok_is_(tline->next, "+")) {
1747             tline = tline->next;
1748             searching.plus = true;
1749         }
1750         mmac = (MMacro *) hash_findix(&mmacros, searching.name);
1751         while (mmac) {
1752             if (!strcmp(mmac->name, searching.name) &&
1753                 (mmac->nparam_min <= searching.nparam_max
1754                  || searching.plus)
1755                 && (searching.nparam_min <= mmac->nparam_max
1756                     || mmac->plus)) {
1757                 found = true;
1758                 break;
1759             }
1760             mmac = mmac->next;
1761         }
1762         if (tline && tline->next)
1763             error(ERR_WARNING|ERR_PASS1,
1764                   "trailing garbage after %%ifmacro ignored");
1765         nasm_free(searching.name);
1766         j = found;
1767         break;
1768     }
1769
1770     case PPC_IFID:
1771         needtype = TOK_ID;
1772         goto iftype;
1773     case PPC_IFNUM:
1774         needtype = TOK_NUMBER;
1775         goto iftype;
1776     case PPC_IFSTR:
1777         needtype = TOK_STRING;
1778         goto iftype;
1779
1780 iftype:
1781         t = tline = expand_smacro(tline);
1782
1783         while (tok_type_(t, TOK_WHITESPACE) ||
1784                (needtype == TOK_NUMBER &&
1785                 tok_type_(t, TOK_OTHER) &&
1786                 (t->text[0] == '-' || t->text[0] == '+') &&
1787                 !t->text[1]))
1788             t = t->next;
1789
1790         j = tok_type_(t, needtype);
1791         break;
1792
1793     case PPC_IFTOKEN:
1794         t = tline = expand_smacro(tline);
1795         while (tok_type_(t, TOK_WHITESPACE))
1796             t = t->next;
1797
1798         j = false;
1799         if (t) {
1800             t = t->next;        /* Skip the actual token */
1801             while (tok_type_(t, TOK_WHITESPACE))
1802                 t = t->next;
1803             j = !t;             /* Should be nothing left */
1804         }
1805         break;
1806
1807     case PPC_IFEMPTY:
1808         t = tline = expand_smacro(tline);
1809         while (tok_type_(t, TOK_WHITESPACE))
1810             t = t->next;
1811
1812         j = !t;                 /* Should be empty */
1813         break;
1814
1815     case PPC_IF:
1816         t = tline = expand_smacro(tline);
1817         tptr = &t;
1818         tokval.t_type = TOKEN_INVALID;
1819         evalresult = evaluate(ppscan, tptr, &tokval,
1820                               NULL, pass | CRITICAL, error, NULL);
1821         if (!evalresult)
1822             return -1;
1823         if (tokval.t_type)
1824             error(ERR_WARNING|ERR_PASS1,
1825                   "trailing garbage after expression ignored");
1826         if (!is_simple(evalresult)) {
1827             error(ERR_NONFATAL,
1828                   "non-constant value given to `%s'", pp_directives[ct]);
1829             goto fail;
1830         }
1831         j = reloc_value(evalresult) != 0;
1832         break;
1833
1834     default:
1835         error(ERR_FATAL,
1836               "preprocessor directive `%s' not yet implemented",
1837               pp_directives[ct]);
1838         goto fail;
1839     }
1840
1841     free_tlist(origline);
1842     return j ^ PP_NEGATIVE(ct);
1843
1844 fail:
1845     free_tlist(origline);
1846     return -1;
1847 }
1848
1849 /*
1850  * Common code for defining an smacro
1851  */
1852 static bool define_smacro(Context *ctx, const char *mname, bool casesense,
1853                           int nparam, Token *expansion)
1854 {
1855     SMacro *smac, **smhead;
1856     struct hash_table *smtbl;
1857
1858     if (smacro_defined(ctx, mname, nparam, &smac, casesense)) {
1859         if (!smac) {
1860             error(ERR_WARNING|ERR_PASS1,
1861                   "single-line macro `%s' defined both with and"
1862                   " without parameters", mname);
1863             /*
1864              * Some instances of the old code considered this a failure,
1865              * some others didn't.  What is the right thing to do here?
1866              */
1867             free_tlist(expansion);
1868             return false;       /* Failure */
1869         } else {
1870             /*
1871              * We're redefining, so we have to take over an
1872              * existing SMacro structure. This means freeing
1873              * what was already in it.
1874              */
1875             nasm_free(smac->name);
1876             free_tlist(smac->expansion);
1877         }
1878     } else {
1879         smtbl  = ctx ? &ctx->localmac : &smacros;
1880         smhead = (SMacro **) hash_findi_add(smtbl, mname);
1881         smac = nasm_malloc(sizeof(SMacro));
1882         smac->next = *smhead;
1883         *smhead = smac;
1884     }
1885     smac->name = nasm_strdup(mname);
1886     smac->casesense = casesense;
1887     smac->nparam = nparam;
1888     smac->expansion = expansion;
1889     smac->in_progress = false;
1890     return true;                /* Success */
1891 }
1892
1893 /*
1894  * Undefine an smacro
1895  */
1896 static void undef_smacro(Context *ctx, const char *mname)
1897 {
1898     SMacro **smhead, *s, **sp;
1899     struct hash_table *smtbl;
1900
1901     smtbl = ctx ? &ctx->localmac : &smacros;
1902     smhead = (SMacro **)hash_findi(smtbl, mname, NULL);
1903
1904     if (smhead) {
1905         /*
1906          * We now have a macro name... go hunt for it.
1907          */
1908         sp = smhead;
1909         while ((s = *sp) != NULL) {
1910             if (!mstrcmp(s->name, mname, s->casesense)) {
1911                 *sp = s->next;
1912                 nasm_free(s->name);
1913                 free_tlist(s->expansion);
1914                 nasm_free(s);
1915             } else {
1916                 sp = &s->next;
1917             }
1918         }
1919     }
1920 }
1921
1922 /*
1923  * Parse a mmacro specification.
1924  */
1925 static bool parse_mmacro_spec(Token *tline, MMacro *def, const char *directive)
1926 {
1927     bool err;
1928
1929     tline = tline->next;
1930     skip_white_(tline);
1931     tline = expand_id(tline);
1932     if (!tok_type_(tline, TOK_ID)) {
1933         error(ERR_NONFATAL, "`%s' expects a macro name", directive);
1934         return false;
1935     }
1936
1937     def->prev = NULL;
1938     def->name = nasm_strdup(tline->text);
1939     def->plus = false;
1940     def->nolist = false;
1941     def->in_progress = 0;
1942     def->rep_nest = NULL;
1943     def->nparam_min = 0;
1944     def->nparam_max = 0;
1945
1946     tline = expand_smacro(tline->next);
1947     skip_white_(tline);
1948     if (!tok_type_(tline, TOK_NUMBER)) {
1949         error(ERR_NONFATAL, "`%s' expects a parameter count", directive);
1950     } else {
1951         def->nparam_min = def->nparam_max =
1952             readnum(tline->text, &err);
1953         if (err)
1954             error(ERR_NONFATAL,
1955                   "unable to parse parameter count `%s'", tline->text);
1956     }
1957     if (tline && tok_is_(tline->next, "-")) {
1958         tline = tline->next->next;
1959         if (tok_is_(tline, "*")) {
1960             def->nparam_max = INT_MAX;
1961         } else if (!tok_type_(tline, TOK_NUMBER)) {
1962             error(ERR_NONFATAL,
1963                   "`%s' expects a parameter count after `-'", directive);
1964         } else {
1965             def->nparam_max = readnum(tline->text, &err);
1966             if (err) {
1967                 error(ERR_NONFATAL, "unable to parse parameter count `%s'",
1968                       tline->text);
1969             }
1970             if (def->nparam_min > def->nparam_max) {
1971                 error(ERR_NONFATAL, "minimum parameter count exceeds maximum");
1972             }
1973         }
1974     }
1975     if (tline && tok_is_(tline->next, "+")) {
1976         tline = tline->next;
1977         def->plus = true;
1978     }
1979     if (tline && tok_type_(tline->next, TOK_ID) &&
1980         !nasm_stricmp(tline->next->text, ".nolist")) {
1981         tline = tline->next;
1982         def->nolist = true;
1983     }
1984
1985     /*
1986      * Handle default parameters.
1987      */
1988     if (tline && tline->next) {
1989         def->dlist = tline->next;
1990         tline->next = NULL;
1991         count_mmac_params(def->dlist, &def->ndefs, &def->defaults);
1992     } else {
1993         def->dlist = NULL;
1994         def->defaults = NULL;
1995     }
1996     def->expansion = NULL;
1997
1998     if (def->defaults && def->ndefs > def->nparam_max - def->nparam_min &&
1999         !def->plus)
2000         error(ERR_WARNING|ERR_PASS1|ERR_WARN_MDP,
2001               "too many default macro parameters");
2002
2003     return true;
2004 }
2005
2006
2007 /*
2008  * Decode a size directive
2009  */
2010 static int parse_size(const char *str) {
2011     static const char *size_names[] =
2012         { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
2013     static const int sizes[] =
2014         { 0, 1, 4, 16, 8, 10, 2, 32 };
2015
2016     return sizes[bsii(str, size_names, elements(size_names))+1];
2017 }
2018
2019 /*
2020  * nasm_unquote with error if the string contains NUL characters.
2021  * If the string contains NUL characters, issue an error and return
2022  * the C len, i.e. truncate at the NUL.
2023  */
2024 static size_t nasm_unquote_cstr(char *qstr, enum preproc_token directive)
2025 {
2026     size_t len = nasm_unquote(qstr, NULL);
2027     size_t clen = strlen(qstr);
2028
2029     if (len != clen)
2030         error(ERR_NONFATAL, "NUL character in `%s' directive",
2031               pp_directives[directive]);
2032
2033     return clen;
2034 }
2035
2036 /**
2037  * find and process preprocessor directive in passed line
2038  * Find out if a line contains a preprocessor directive, and deal
2039  * with it if so.
2040  *
2041  * If a directive _is_ found, it is the responsibility of this routine
2042  * (and not the caller) to free_tlist() the line.
2043  *
2044  * @param tline a pointer to the current tokeninzed line linked list
2045  * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
2046  *
2047  */
2048 static int do_directive(Token * tline)
2049 {
2050     enum preproc_token i;
2051     int j;
2052     bool err;
2053     int nparam;
2054     bool nolist;
2055     bool casesense;
2056     int k, m;
2057     int offset;
2058     char *p, *pp;
2059     const char *mname;
2060     Include *inc;
2061     Context *ctx;
2062     Cond *cond;
2063     MMacro *mmac, **mmhead;
2064     Token *t, *tt, *param_start, *macro_start, *last, **tptr, *origline;
2065     Line *l;
2066     struct tokenval tokval;
2067     expr *evalresult;
2068     MMacro *tmp_defining;       /* Used when manipulating rep_nest */
2069     int64_t count;
2070     size_t len;
2071     int severity;
2072
2073     origline = tline;
2074
2075     skip_white_(tline);
2076     if (!tline || !tok_type_(tline, TOK_PREPROC_ID) ||
2077         (tline->text[1] == '%' || tline->text[1] == '$'
2078          || tline->text[1] == '!'))
2079         return NO_DIRECTIVE_FOUND;
2080
2081     i = pp_token_hash(tline->text);
2082
2083     /*
2084      * If we're in a non-emitting branch of a condition construct,
2085      * or walking to the end of an already terminated %rep block,
2086      * we should ignore all directives except for condition
2087      * directives.
2088      */
2089     if (((istk->conds && !emitting(istk->conds->state)) ||
2090          (istk->mstk && !istk->mstk->in_progress)) && !is_condition(i)) {
2091         return NO_DIRECTIVE_FOUND;
2092     }
2093
2094     /*
2095      * If we're defining a macro or reading a %rep block, we should
2096      * ignore all directives except for %macro/%imacro (which nest),
2097      * %endm/%endmacro, and (only if we're in a %rep block) %endrep.
2098      * If we're in a %rep block, another %rep nests, so should be let through.
2099      */
2100     if (defining && i != PP_MACRO && i != PP_IMACRO &&
2101         i != PP_RMACRO &&  i != PP_IRMACRO &&
2102         i != PP_ENDMACRO && i != PP_ENDM &&
2103         (defining->name || (i != PP_ENDREP && i != PP_REP))) {
2104         return NO_DIRECTIVE_FOUND;
2105     }
2106
2107     if (defining) {
2108         if (i == PP_MACRO || i == PP_IMACRO ||
2109             i == PP_RMACRO || i == PP_IRMACRO) {
2110             nested_mac_count++;
2111             return NO_DIRECTIVE_FOUND;
2112         } else if (nested_mac_count > 0) {
2113             if (i == PP_ENDMACRO) {
2114                 nested_mac_count--;
2115                 return NO_DIRECTIVE_FOUND;
2116             }
2117         }
2118         if (!defining->name) {
2119             if (i == PP_REP) {
2120                 nested_rep_count++;
2121                 return NO_DIRECTIVE_FOUND;
2122             } else if (nested_rep_count > 0) {
2123                 if (i == PP_ENDREP) {
2124                     nested_rep_count--;
2125                     return NO_DIRECTIVE_FOUND;
2126                 }
2127             }
2128         }
2129     }
2130
2131     switch (i) {
2132     case PP_INVALID:
2133         error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
2134               tline->text);
2135         return NO_DIRECTIVE_FOUND;      /* didn't get it */
2136
2137     case PP_STACKSIZE:
2138         /* Directive to tell NASM what the default stack size is. The
2139          * default is for a 16-bit stack, and this can be overriden with
2140          * %stacksize large.
2141          */
2142         tline = tline->next;
2143         if (tline && tline->type == TOK_WHITESPACE)
2144             tline = tline->next;
2145         if (!tline || tline->type != TOK_ID) {
2146             error(ERR_NONFATAL, "`%%stacksize' missing size parameter");
2147             free_tlist(origline);
2148             return DIRECTIVE_FOUND;
2149         }
2150         if (nasm_stricmp(tline->text, "flat") == 0) {
2151             /* All subsequent ARG directives are for a 32-bit stack */
2152             StackSize = 4;
2153             StackPointer = "ebp";
2154             ArgOffset = 8;
2155             LocalOffset = 0;
2156         } else if (nasm_stricmp(tline->text, "flat64") == 0) {
2157             /* All subsequent ARG directives are for a 64-bit stack */
2158             StackSize = 8;
2159             StackPointer = "rbp";
2160             ArgOffset = 16;
2161             LocalOffset = 0;
2162         } else if (nasm_stricmp(tline->text, "large") == 0) {
2163             /* All subsequent ARG directives are for a 16-bit stack,
2164              * far function call.
2165              */
2166             StackSize = 2;
2167             StackPointer = "bp";
2168             ArgOffset = 4;
2169             LocalOffset = 0;
2170         } else if (nasm_stricmp(tline->text, "small") == 0) {
2171             /* All subsequent ARG directives are for a 16-bit stack,
2172              * far function call. We don't support near functions.
2173              */
2174             StackSize = 2;
2175             StackPointer = "bp";
2176             ArgOffset = 6;
2177             LocalOffset = 0;
2178         } else {
2179             error(ERR_NONFATAL, "`%%stacksize' invalid size type");
2180             free_tlist(origline);
2181             return DIRECTIVE_FOUND;
2182         }
2183         free_tlist(origline);
2184         return DIRECTIVE_FOUND;
2185
2186     case PP_ARG:
2187         /* TASM like ARG directive to define arguments to functions, in
2188          * the following form:
2189          *
2190          *      ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2191          */
2192         offset = ArgOffset;
2193         do {
2194             char *arg, directive[256];
2195             int size = StackSize;
2196
2197             /* Find the argument name */
2198             tline = tline->next;
2199             if (tline && tline->type == TOK_WHITESPACE)
2200                 tline = tline->next;
2201             if (!tline || tline->type != TOK_ID) {
2202                 error(ERR_NONFATAL, "`%%arg' missing argument parameter");
2203                 free_tlist(origline);
2204                 return DIRECTIVE_FOUND;
2205             }
2206             arg = tline->text;
2207
2208             /* Find the argument size type */
2209             tline = tline->next;
2210             if (!tline || tline->type != TOK_OTHER
2211                 || tline->text[0] != ':') {
2212                 error(ERR_NONFATAL,
2213                       "Syntax error processing `%%arg' directive");
2214                 free_tlist(origline);
2215                 return DIRECTIVE_FOUND;
2216             }
2217             tline = tline->next;
2218             if (!tline || tline->type != TOK_ID) {
2219                 error(ERR_NONFATAL, "`%%arg' missing size type parameter");
2220                 free_tlist(origline);
2221                 return DIRECTIVE_FOUND;
2222             }
2223
2224             /* Allow macro expansion of type parameter */
2225             tt = tokenize(tline->text);
2226             tt = expand_smacro(tt);
2227             size = parse_size(tt->text);
2228             if (!size) {
2229                 error(ERR_NONFATAL,
2230                       "Invalid size type for `%%arg' missing directive");
2231                 free_tlist(tt);
2232                 free_tlist(origline);
2233                 return DIRECTIVE_FOUND;
2234             }
2235             free_tlist(tt);
2236
2237             /* Round up to even stack slots */
2238             size = ALIGN(size, StackSize);
2239
2240             /* Now define the macro for the argument */
2241             snprintf(directive, sizeof(directive), "%%define %s (%s+%d)",
2242                      arg, StackPointer, offset);
2243             do_directive(tokenize(directive));
2244             offset += size;
2245
2246             /* Move to the next argument in the list */
2247             tline = tline->next;
2248             if (tline && tline->type == TOK_WHITESPACE)
2249                 tline = tline->next;
2250         } while (tline && tline->type == TOK_OTHER && tline->text[0] == ',');
2251         ArgOffset = offset;
2252         free_tlist(origline);
2253         return DIRECTIVE_FOUND;
2254
2255     case PP_LOCAL:
2256         /* TASM like LOCAL directive to define local variables for a
2257          * function, in the following form:
2258          *
2259          *      LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2260          *
2261          * The '= LocalSize' at the end is ignored by NASM, but is
2262          * required by TASM to define the local parameter size (and used
2263          * by the TASM macro package).
2264          */
2265         offset = LocalOffset;
2266         do {
2267             char *local, directive[256];
2268             int size = StackSize;
2269
2270             /* Find the argument name */
2271             tline = tline->next;
2272             if (tline && tline->type == TOK_WHITESPACE)
2273                 tline = tline->next;
2274             if (!tline || tline->type != TOK_ID) {
2275                 error(ERR_NONFATAL,
2276                       "`%%local' missing argument parameter");
2277                 free_tlist(origline);
2278                 return DIRECTIVE_FOUND;
2279             }
2280             local = tline->text;
2281
2282             /* Find the argument size type */
2283             tline = tline->next;
2284             if (!tline || tline->type != TOK_OTHER
2285                 || tline->text[0] != ':') {
2286                 error(ERR_NONFATAL,
2287                       "Syntax error processing `%%local' directive");
2288                 free_tlist(origline);
2289                 return DIRECTIVE_FOUND;
2290             }
2291             tline = tline->next;
2292             if (!tline || tline->type != TOK_ID) {
2293                 error(ERR_NONFATAL,
2294                       "`%%local' missing size type parameter");
2295                 free_tlist(origline);
2296                 return DIRECTIVE_FOUND;
2297             }
2298
2299             /* Allow macro expansion of type parameter */
2300             tt = tokenize(tline->text);
2301             tt = expand_smacro(tt);
2302             size = parse_size(tt->text);
2303             if (!size) {
2304                 error(ERR_NONFATAL,
2305                       "Invalid size type for `%%local' missing directive");
2306                 free_tlist(tt);
2307                 free_tlist(origline);
2308                 return DIRECTIVE_FOUND;
2309             }
2310             free_tlist(tt);
2311
2312             /* Round up to even stack slots */
2313             size = ALIGN(size, StackSize);
2314
2315             offset += size;     /* Negative offset, increment before */
2316
2317             /* Now define the macro for the argument */
2318             snprintf(directive, sizeof(directive), "%%define %s (%s-%d)",
2319                      local, StackPointer, offset);
2320             do_directive(tokenize(directive));
2321
2322             /* Now define the assign to setup the enter_c macro correctly */
2323             snprintf(directive, sizeof(directive),
2324                      "%%assign %%$localsize %%$localsize+%d", size);
2325             do_directive(tokenize(directive));
2326
2327             /* Move to the next argument in the list */
2328             tline = tline->next;
2329             if (tline && tline->type == TOK_WHITESPACE)
2330                 tline = tline->next;
2331         } while (tline && tline->type == TOK_OTHER && tline->text[0] == ',');
2332         LocalOffset = offset;
2333         free_tlist(origline);
2334         return DIRECTIVE_FOUND;
2335
2336     case PP_CLEAR:
2337         if (tline->next)
2338             error(ERR_WARNING|ERR_PASS1,
2339                   "trailing garbage after `%%clear' ignored");
2340         free_macros();
2341         init_macros();
2342         free_tlist(origline);
2343         return DIRECTIVE_FOUND;
2344
2345     case PP_DEPEND:
2346         t = tline->next = expand_smacro(tline->next);
2347         skip_white_(t);
2348         if (!t || (t->type != TOK_STRING &&
2349                    t->type != TOK_INTERNAL_STRING)) {
2350             error(ERR_NONFATAL, "`%%depend' expects a file name");
2351             free_tlist(origline);
2352             return DIRECTIVE_FOUND;     /* but we did _something_ */
2353         }
2354         if (t->next)
2355             error(ERR_WARNING|ERR_PASS1,
2356                   "trailing garbage after `%%depend' ignored");
2357         p = t->text;
2358         if (t->type != TOK_INTERNAL_STRING)
2359             nasm_unquote_cstr(p, i);
2360         if (dephead && !in_list(*dephead, p)) {
2361             StrList *sl = nasm_malloc(strlen(p)+1+sizeof sl->next);
2362             sl->next = NULL;
2363             strcpy(sl->str, p);
2364             *deptail = sl;
2365             deptail = &sl->next;
2366         }
2367         free_tlist(origline);
2368         return DIRECTIVE_FOUND;
2369
2370     case PP_INCLUDE:
2371         t = tline->next = expand_smacro(tline->next);
2372         skip_white_(t);
2373
2374         if (!t || (t->type != TOK_STRING &&
2375                    t->type != TOK_INTERNAL_STRING)) {
2376             error(ERR_NONFATAL, "`%%include' expects a file name");
2377             free_tlist(origline);
2378             return DIRECTIVE_FOUND;     /* but we did _something_ */
2379         }
2380         if (t->next)
2381             error(ERR_WARNING|ERR_PASS1,
2382                   "trailing garbage after `%%include' ignored");
2383         p = t->text;
2384         if (t->type != TOK_INTERNAL_STRING)
2385             nasm_unquote_cstr(p, i);
2386         inc = nasm_malloc(sizeof(Include));
2387         inc->next = istk;
2388         inc->conds = NULL;
2389         inc->fp = inc_fopen(p, dephead, &deptail, pass == 0);
2390         if (!inc->fp) {
2391             /* -MG given but file not found */
2392             nasm_free(inc);
2393         } else {
2394             inc->fname = src_set_fname(nasm_strdup(p));
2395             inc->lineno = src_set_linnum(0);
2396             inc->lineinc = 1;
2397             inc->expansion = NULL;
2398             inc->mstk = NULL;
2399             istk = inc;
2400             list->uplevel(LIST_INCLUDE);
2401         }
2402         free_tlist(origline);
2403         return DIRECTIVE_FOUND;
2404
2405     case PP_USE:
2406     {
2407         static macros_t *use_pkg;
2408         const char *pkg_macro = NULL;
2409
2410         tline = tline->next;
2411         skip_white_(tline);
2412         tline = expand_id(tline);
2413
2414         if (!tline || (tline->type != TOK_STRING &&
2415                        tline->type != TOK_INTERNAL_STRING &&
2416                        tline->type != TOK_ID)) {
2417             error(ERR_NONFATAL, "`%%use' expects a package name");
2418             free_tlist(origline);
2419             return DIRECTIVE_FOUND;     /* but we did _something_ */
2420         }
2421         if (tline->next)
2422             error(ERR_WARNING|ERR_PASS1,
2423                   "trailing garbage after `%%use' ignored");
2424         if (tline->type == TOK_STRING)
2425             nasm_unquote_cstr(tline->text, i);
2426         use_pkg = nasm_stdmac_find_package(tline->text);
2427         if (!use_pkg)
2428             error(ERR_NONFATAL, "unknown `%%use' package: %s", tline->text);
2429         else
2430             pkg_macro = (char *)use_pkg + 1; /* The first string will be <%define>__USE_*__ */
2431         if (use_pkg && smacro_defined(NULL, pkg_macro, 0, NULL, true)) {
2432             /* Not already included, go ahead and include it */
2433             stdmacpos = use_pkg;
2434         }
2435         free_tlist(origline);
2436         return DIRECTIVE_FOUND;
2437     }
2438     case PP_PUSH:
2439     case PP_REPL:
2440     case PP_POP:
2441         tline = tline->next;
2442         skip_white_(tline);
2443         tline = expand_id(tline);
2444         if (tline) {
2445             if (!tok_type_(tline, TOK_ID)) {
2446                 error(ERR_NONFATAL, "`%s' expects a context identifier",
2447                       pp_directives[i]);
2448                 free_tlist(origline);
2449                 return DIRECTIVE_FOUND;     /* but we did _something_ */
2450             }
2451             if (tline->next)
2452                 error(ERR_WARNING|ERR_PASS1,
2453                       "trailing garbage after `%s' ignored",
2454                       pp_directives[i]);
2455             p = nasm_strdup(tline->text);
2456         } else {
2457             p = NULL; /* Anonymous */
2458         }
2459
2460         if (i == PP_PUSH) {
2461             ctx = nasm_malloc(sizeof(Context));
2462             ctx->next = cstk;
2463             hash_init(&ctx->localmac, HASH_SMALL);
2464             ctx->name = p;
2465             ctx->number = unique++;
2466             cstk = ctx;
2467         } else {
2468             /* %pop or %repl */
2469             if (!cstk) {
2470                 error(ERR_NONFATAL, "`%s': context stack is empty",
2471                       pp_directives[i]);
2472             } else if (i == PP_POP) {
2473                 if (p && (!cstk->name || nasm_stricmp(p, cstk->name)))
2474                     error(ERR_NONFATAL, "`%%pop' in wrong context: %s, "
2475                           "expected %s",
2476                           cstk->name ? cstk->name : "anonymous", p);
2477                 else
2478                     ctx_pop();
2479             } else {
2480                 /* i == PP_REPL */
2481                 nasm_free(cstk->name);
2482                 cstk->name = p;
2483                 p = NULL;
2484             }
2485             nasm_free(p);
2486         }
2487         free_tlist(origline);
2488         return DIRECTIVE_FOUND;
2489     case PP_FATAL:
2490         severity = ERR_FATAL;
2491         goto issue_error;
2492     case PP_ERROR:
2493         severity = ERR_NONFATAL;
2494         goto issue_error;
2495     case PP_WARNING:
2496         severity = ERR_WARNING|ERR_WARN_USER;
2497         goto issue_error;
2498
2499 issue_error:
2500     {
2501         /* Only error out if this is the final pass */
2502         if (pass != 2 && i != PP_FATAL)
2503             return DIRECTIVE_FOUND;
2504
2505         tline->next = expand_smacro(tline->next);
2506         tline = tline->next;
2507         skip_white_(tline);
2508         t = tline ? tline->next : NULL;
2509         skip_white_(t);
2510         if (tok_type_(tline, TOK_STRING) && !t) {
2511             /* The line contains only a quoted string */
2512             p = tline->text;
2513             nasm_unquote(p, NULL); /* Ignore NUL character truncation */
2514             error(severity, "%s",  p);
2515         } else {
2516             /* Not a quoted string, or more than a quoted string */
2517             p = detoken(tline, false);
2518             error(severity, "%s",  p);
2519             nasm_free(p);
2520         }
2521         free_tlist(origline);
2522         return DIRECTIVE_FOUND;
2523     }
2524
2525     CASE_PP_IF:
2526         if (istk->conds && !emitting(istk->conds->state))
2527             j = COND_NEVER;
2528         else {
2529             j = if_condition(tline->next, i);
2530             tline->next = NULL; /* it got freed */
2531             j = j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2532         }
2533         cond = nasm_malloc(sizeof(Cond));
2534         cond->next = istk->conds;
2535         cond->state = j;
2536         istk->conds = cond;
2537         if(istk->mstk)
2538             istk->mstk->condcnt ++;
2539         free_tlist(origline);
2540         return DIRECTIVE_FOUND;
2541
2542     CASE_PP_ELIF:
2543         if (!istk->conds)
2544             error(ERR_FATAL, "`%s': no matching `%%if'", pp_directives[i]);
2545         switch(istk->conds->state) {
2546         case COND_IF_TRUE:
2547             istk->conds->state = COND_DONE;
2548             break;
2549
2550         case COND_DONE:
2551         case COND_NEVER:
2552             break;
2553
2554         case COND_ELSE_TRUE:
2555         case COND_ELSE_FALSE:
2556             error_precond(ERR_WARNING|ERR_PASS1,
2557                           "`%%elif' after `%%else' ignored");
2558             istk->conds->state = COND_NEVER;
2559             break;
2560
2561         case COND_IF_FALSE:
2562             /*
2563              * IMPORTANT: In the case of %if, we will already have
2564              * called expand_mmac_params(); however, if we're
2565              * processing an %elif we must have been in a
2566              * non-emitting mode, which would have inhibited
2567              * the normal invocation of expand_mmac_params().
2568              * Therefore, we have to do it explicitly here.
2569              */
2570             j = if_condition(expand_mmac_params(tline->next), i);
2571             tline->next = NULL; /* it got freed */
2572             istk->conds->state =
2573                 j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2574             break;
2575         }
2576         free_tlist(origline);
2577         return DIRECTIVE_FOUND;
2578
2579     case PP_ELSE:
2580         if (tline->next)
2581             error_precond(ERR_WARNING|ERR_PASS1,
2582                           "trailing garbage after `%%else' ignored");
2583         if (!istk->conds)
2584             error(ERR_FATAL, "`%%else': no matching `%%if'");
2585         switch(istk->conds->state) {
2586         case COND_IF_TRUE:
2587         case COND_DONE:
2588             istk->conds->state = COND_ELSE_FALSE;
2589             break;
2590
2591         case COND_NEVER:
2592             break;
2593
2594         case COND_IF_FALSE:
2595             istk->conds->state = COND_ELSE_TRUE;
2596             break;
2597
2598         case COND_ELSE_TRUE:
2599         case COND_ELSE_FALSE:
2600             error_precond(ERR_WARNING|ERR_PASS1,
2601                           "`%%else' after `%%else' ignored.");
2602             istk->conds->state = COND_NEVER;
2603             break;
2604         }
2605         free_tlist(origline);
2606         return DIRECTIVE_FOUND;
2607
2608     case PP_ENDIF:
2609         if (tline->next)
2610             error_precond(ERR_WARNING|ERR_PASS1,
2611                           "trailing garbage after `%%endif' ignored");
2612         if (!istk->conds)
2613             error(ERR_FATAL, "`%%endif': no matching `%%if'");
2614         cond = istk->conds;
2615         istk->conds = cond->next;
2616         nasm_free(cond);
2617         if(istk->mstk)
2618             istk->mstk->condcnt --;
2619         free_tlist(origline);
2620         return DIRECTIVE_FOUND;
2621
2622     case PP_RMACRO:
2623     case PP_IRMACRO:
2624     case PP_MACRO:
2625     case PP_IMACRO:
2626         if (defining) {
2627             error(ERR_FATAL, "`%s': already defining a macro",
2628                   pp_directives[i]);
2629             return DIRECTIVE_FOUND;
2630         }
2631         defining = nasm_malloc(sizeof(MMacro));
2632         defining->max_depth =
2633             (i == PP_RMACRO) || (i == PP_IRMACRO) ? DEADMAN_LIMIT : 0;
2634         defining->casesense = (i == PP_MACRO) || (i == PP_RMACRO);
2635         if (!parse_mmacro_spec(tline, defining, pp_directives[i])) {
2636             nasm_free(defining);
2637             defining = NULL;
2638             return DIRECTIVE_FOUND;
2639         }
2640
2641         mmac = (MMacro *) hash_findix(&mmacros, defining->name);
2642         while (mmac) {
2643             if (!strcmp(mmac->name, defining->name) &&
2644                 (mmac->nparam_min <= defining->nparam_max
2645                  || defining->plus)
2646                 && (defining->nparam_min <= mmac->nparam_max
2647                     || mmac->plus)) {
2648                 error(ERR_WARNING|ERR_PASS1,
2649                       "redefining multi-line macro `%s'", defining->name);
2650                 return DIRECTIVE_FOUND;
2651             }
2652             mmac = mmac->next;
2653         }
2654         free_tlist(origline);
2655         return DIRECTIVE_FOUND;
2656
2657     case PP_ENDM:
2658     case PP_ENDMACRO:
2659         if (! (defining && defining->name)) {
2660             error(ERR_NONFATAL, "`%s': not defining a macro", tline->text);
2661             return DIRECTIVE_FOUND;
2662         }
2663         mmhead = (MMacro **) hash_findi_add(&mmacros, defining->name);
2664         defining->next = *mmhead;
2665         *mmhead = defining;
2666         defining = NULL;
2667         free_tlist(origline);
2668         return DIRECTIVE_FOUND;
2669
2670     case PP_EXITMACRO:
2671         /*
2672          * We must search along istk->expansion until we hit a
2673          * macro-end marker for a macro with a name. Then we
2674          * bypass all lines between exitmacro and endmacro.
2675          */
2676         for (l = istk->expansion; l; l = l->next)
2677             if (l->finishes && l->finishes->name)
2678                 break;
2679
2680         if (l) {
2681             /*
2682              * Remove all conditional entries relative to this
2683              * macro invocation. (safe to do in this context)
2684              */
2685             for ( ; l->finishes->condcnt > 0; l->finishes->condcnt --) {
2686                 cond = istk->conds;
2687                 istk->conds = cond->next;
2688                 nasm_free(cond);
2689             }
2690             istk->expansion = l;
2691         } else {
2692             error(ERR_NONFATAL, "`%%exitmacro' not within `%%macro' block");
2693         }
2694         free_tlist(origline);
2695         return DIRECTIVE_FOUND;
2696
2697     case PP_UNMACRO:
2698     case PP_UNIMACRO:
2699     {
2700         MMacro **mmac_p;
2701         MMacro spec;
2702
2703         spec.casesense = (i == PP_UNMACRO);
2704         if (!parse_mmacro_spec(tline, &spec, pp_directives[i])) {
2705             return DIRECTIVE_FOUND;
2706         }
2707         mmac_p = (MMacro **) hash_findi(&mmacros, spec.name, NULL);
2708         while (mmac_p && *mmac_p) {
2709             mmac = *mmac_p;
2710             if (mmac->casesense == spec.casesense &&
2711                 !mstrcmp(mmac->name, spec.name, spec.casesense) &&
2712                 mmac->nparam_min == spec.nparam_min &&
2713                 mmac->nparam_max == spec.nparam_max &&
2714                 mmac->plus == spec.plus) {
2715                 *mmac_p = mmac->next;
2716                 free_mmacro(mmac);
2717             } else {
2718                 mmac_p = &mmac->next;
2719             }
2720         }
2721         free_tlist(origline);
2722         free_tlist(spec.dlist);
2723         return DIRECTIVE_FOUND;
2724     }
2725
2726     case PP_ROTATE:
2727         if (tline->next && tline->next->type == TOK_WHITESPACE)
2728             tline = tline->next;
2729         if (!tline->next) {
2730             free_tlist(origline);
2731             error(ERR_NONFATAL, "`%%rotate' missing rotate count");
2732             return DIRECTIVE_FOUND;
2733         }
2734         t = expand_smacro(tline->next);
2735         tline->next = NULL;
2736         free_tlist(origline);
2737         tline = t;
2738         tptr = &t;
2739         tokval.t_type = TOKEN_INVALID;
2740         evalresult =
2741             evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2742         free_tlist(tline);
2743         if (!evalresult)
2744             return DIRECTIVE_FOUND;
2745         if (tokval.t_type)
2746             error(ERR_WARNING|ERR_PASS1,
2747                   "trailing garbage after expression ignored");
2748         if (!is_simple(evalresult)) {
2749             error(ERR_NONFATAL, "non-constant value given to `%%rotate'");
2750             return DIRECTIVE_FOUND;
2751         }
2752         mmac = istk->mstk;
2753         while (mmac && !mmac->name)     /* avoid mistaking %reps for macros */
2754             mmac = mmac->next_active;
2755         if (!mmac) {
2756             error(ERR_NONFATAL, "`%%rotate' invoked outside a macro call");
2757         } else if (mmac->nparam == 0) {
2758             error(ERR_NONFATAL,
2759                   "`%%rotate' invoked within macro without parameters");
2760         } else {
2761             int rotate = mmac->rotate + reloc_value(evalresult);
2762
2763             rotate %= (int)mmac->nparam;
2764             if (rotate < 0)
2765                 rotate += mmac->nparam;
2766
2767             mmac->rotate = rotate;
2768         }
2769         return DIRECTIVE_FOUND;
2770
2771     case PP_REP:
2772         nolist = false;
2773         do {
2774             tline = tline->next;
2775         } while (tok_type_(tline, TOK_WHITESPACE));
2776
2777         if (tok_type_(tline, TOK_ID) &&
2778             nasm_stricmp(tline->text, ".nolist") == 0) {
2779             nolist = true;
2780             do {
2781                 tline = tline->next;
2782             } while (tok_type_(tline, TOK_WHITESPACE));
2783         }
2784
2785         if (tline) {
2786             t = expand_smacro(tline);
2787             tptr = &t;
2788             tokval.t_type = TOKEN_INVALID;
2789             evalresult =
2790                 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2791             if (!evalresult) {
2792                 free_tlist(origline);
2793                 return DIRECTIVE_FOUND;
2794             }
2795             if (tokval.t_type)
2796                 error(ERR_WARNING|ERR_PASS1,
2797                       "trailing garbage after expression ignored");
2798             if (!is_simple(evalresult)) {
2799                 error(ERR_NONFATAL, "non-constant value given to `%%rep'");
2800                 return DIRECTIVE_FOUND;
2801             }
2802             count = reloc_value(evalresult) + 1;
2803         } else {
2804             error(ERR_NONFATAL, "`%%rep' expects a repeat count");
2805             count = 0;
2806         }
2807         free_tlist(origline);
2808
2809         tmp_defining = defining;
2810         defining = nasm_malloc(sizeof(MMacro));
2811         defining->prev = NULL;
2812         defining->name = NULL;  /* flags this macro as a %rep block */
2813         defining->casesense = false;
2814         defining->plus = false;
2815         defining->nolist = nolist;
2816         defining->in_progress = count;
2817         defining->max_depth = 0;
2818         defining->nparam_min = defining->nparam_max = 0;
2819         defining->defaults = NULL;
2820         defining->dlist = NULL;
2821         defining->expansion = NULL;
2822         defining->next_active = istk->mstk;
2823         defining->rep_nest = tmp_defining;
2824         return DIRECTIVE_FOUND;
2825
2826     case PP_ENDREP:
2827         if (!defining || defining->name) {
2828             error(ERR_NONFATAL, "`%%endrep': no matching `%%rep'");
2829             return DIRECTIVE_FOUND;
2830         }
2831
2832         /*
2833          * Now we have a "macro" defined - although it has no name
2834          * and we won't be entering it in the hash tables - we must
2835          * push a macro-end marker for it on to istk->expansion.
2836          * After that, it will take care of propagating itself (a
2837          * macro-end marker line for a macro which is really a %rep
2838          * block will cause the macro to be re-expanded, complete
2839          * with another macro-end marker to ensure the process
2840          * continues) until the whole expansion is forcibly removed
2841          * from istk->expansion by a %exitrep.
2842          */
2843         l = nasm_malloc(sizeof(Line));
2844         l->next = istk->expansion;
2845         l->finishes = defining;
2846         l->first = NULL;
2847         istk->expansion = l;
2848
2849         istk->mstk = defining;
2850
2851         list->uplevel(defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
2852         tmp_defining = defining;
2853         defining = defining->rep_nest;
2854         free_tlist(origline);
2855         return DIRECTIVE_FOUND;
2856
2857     case PP_EXITREP:
2858         /*
2859          * We must search along istk->expansion until we hit a
2860          * macro-end marker for a macro with no name. Then we set
2861          * its `in_progress' flag to 0.
2862          */
2863         for (l = istk->expansion; l; l = l->next)
2864             if (l->finishes && !l->finishes->name)
2865                 break;
2866
2867         if (l)
2868             l->finishes->in_progress = 1;
2869         else
2870             error(ERR_NONFATAL, "`%%exitrep' not within `%%rep' block");
2871         free_tlist(origline);
2872         return DIRECTIVE_FOUND;
2873
2874     case PP_XDEFINE:
2875     case PP_IXDEFINE:
2876     case PP_DEFINE:
2877     case PP_IDEFINE:
2878         casesense = (i == PP_DEFINE || i == PP_XDEFINE);
2879
2880         tline = tline->next;
2881         skip_white_(tline);
2882         tline = expand_id(tline);
2883         if (!tline || (tline->type != TOK_ID &&
2884                        (tline->type != TOK_PREPROC_ID ||
2885                         tline->text[1] != '$'))) {
2886             error(ERR_NONFATAL, "`%s' expects a macro identifier",
2887                   pp_directives[i]);
2888             free_tlist(origline);
2889             return DIRECTIVE_FOUND;
2890         }
2891
2892         ctx = get_ctx(tline->text, &mname, false);
2893         last = tline;
2894         param_start = tline = tline->next;
2895         nparam = 0;
2896
2897         /* Expand the macro definition now for %xdefine and %ixdefine */
2898         if ((i == PP_XDEFINE) || (i == PP_IXDEFINE))
2899             tline = expand_smacro(tline);
2900
2901         if (tok_is_(tline, "(")) {
2902             /*
2903              * This macro has parameters.
2904              */
2905
2906             tline = tline->next;
2907             while (1) {
2908                 skip_white_(tline);
2909                 if (!tline) {
2910                     error(ERR_NONFATAL, "parameter identifier expected");
2911                     free_tlist(origline);
2912                     return DIRECTIVE_FOUND;
2913                 }
2914                 if (tline->type != TOK_ID) {
2915                     error(ERR_NONFATAL,
2916                           "`%s': parameter identifier expected",
2917                           tline->text);
2918                     free_tlist(origline);
2919                     return DIRECTIVE_FOUND;
2920                 }
2921                 tline->type = TOK_SMAC_PARAM + nparam++;
2922                 tline = tline->next;
2923                 skip_white_(tline);
2924                 if (tok_is_(tline, ",")) {
2925                     tline = tline->next;
2926                 } else {
2927                     if (!tok_is_(tline, ")")) {
2928                         error(ERR_NONFATAL,
2929                               "`)' expected to terminate macro template");
2930                         free_tlist(origline);
2931                         return DIRECTIVE_FOUND;
2932                     }
2933                     break;
2934                 }
2935             }
2936             last = tline;
2937             tline = tline->next;
2938         }
2939         if (tok_type_(tline, TOK_WHITESPACE))
2940             last = tline, tline = tline->next;
2941         macro_start = NULL;
2942         last->next = NULL;
2943         t = tline;
2944         while (t) {
2945             if (t->type == TOK_ID) {
2946                 for (tt = param_start; tt; tt = tt->next)
2947                     if (tt->type >= TOK_SMAC_PARAM &&
2948                         !strcmp(tt->text, t->text))
2949                         t->type = tt->type;
2950             }
2951             tt = t->next;
2952             t->next = macro_start;
2953             macro_start = t;
2954             t = tt;
2955         }
2956         /*
2957          * Good. We now have a macro name, a parameter count, and a
2958          * token list (in reverse order) for an expansion. We ought
2959          * to be OK just to create an SMacro, store it, and let
2960          * free_tlist have the rest of the line (which we have
2961          * carefully re-terminated after chopping off the expansion
2962          * from the end).
2963          */
2964         define_smacro(ctx, mname, casesense, nparam, macro_start);
2965         free_tlist(origline);
2966         return DIRECTIVE_FOUND;
2967
2968     case PP_UNDEF:
2969         tline = tline->next;
2970         skip_white_(tline);
2971         tline = expand_id(tline);
2972         if (!tline || (tline->type != TOK_ID &&
2973                        (tline->type != TOK_PREPROC_ID ||
2974                         tline->text[1] != '$'))) {
2975             error(ERR_NONFATAL, "`%%undef' expects a macro identifier");
2976             free_tlist(origline);
2977             return DIRECTIVE_FOUND;
2978         }
2979         if (tline->next) {
2980             error(ERR_WARNING|ERR_PASS1,
2981                   "trailing garbage after macro name ignored");
2982         }
2983
2984         /* Find the context that symbol belongs to */
2985         ctx = get_ctx(tline->text, &mname, false);
2986         undef_smacro(ctx, mname);
2987         free_tlist(origline);
2988         return DIRECTIVE_FOUND;
2989
2990     case PP_DEFSTR:
2991     case PP_IDEFSTR:
2992         casesense = (i == PP_DEFSTR);
2993
2994         tline = tline->next;
2995         skip_white_(tline);
2996         tline = expand_id(tline);
2997         if (!tline || (tline->type != TOK_ID &&
2998                        (tline->type != TOK_PREPROC_ID ||
2999                         tline->text[1] != '$'))) {
3000             error(ERR_NONFATAL, "`%s' expects a macro identifier",
3001                   pp_directives[i]);
3002             free_tlist(origline);
3003             return DIRECTIVE_FOUND;
3004         }
3005
3006         ctx = get_ctx(tline->text, &mname, false);
3007         last = tline;
3008         tline = expand_smacro(tline->next);
3009         last->next = NULL;
3010
3011         while (tok_type_(tline, TOK_WHITESPACE))
3012             tline = delete_Token(tline);
3013
3014         p = detoken(tline, false);
3015         macro_start = nasm_malloc(sizeof(*macro_start));
3016         macro_start->next = NULL;
3017         macro_start->text = nasm_quote(p, strlen(p));
3018         macro_start->type = TOK_STRING;
3019         macro_start->a.mac = NULL;
3020         nasm_free(p);
3021
3022         /*
3023          * We now have a macro name, an implicit parameter count of
3024          * zero, and a string token to use as an expansion. Create
3025          * and store an SMacro.
3026          */
3027         define_smacro(ctx, mname, casesense, 0, macro_start);
3028         free_tlist(origline);
3029         return DIRECTIVE_FOUND;
3030
3031     case PP_DEFTOK:
3032     case PP_IDEFTOK:
3033         casesense = (i == PP_DEFTOK);
3034
3035         tline = tline->next;
3036         skip_white_(tline);
3037         tline = expand_id(tline);
3038         if (!tline || (tline->type != TOK_ID &&
3039                        (tline->type != TOK_PREPROC_ID ||
3040                         tline->text[1] != '$'))) {
3041             error(ERR_NONFATAL,
3042                   "`%s' expects a macro identifier as first parameter",
3043                   pp_directives[i]);
3044             free_tlist(origline);
3045             return DIRECTIVE_FOUND;
3046         }
3047         ctx = get_ctx(tline->text, &mname, false);
3048         last = tline;
3049         tline = expand_smacro(tline->next);
3050         last->next = NULL;
3051
3052         t = tline;
3053         while (tok_type_(t, TOK_WHITESPACE))
3054             t = t->next;
3055         /* t should now point to the string */
3056         if (t->type != TOK_STRING) {
3057             error(ERR_NONFATAL,
3058                   "`%s` requires string as second parameter",
3059                   pp_directives[i]);
3060             free_tlist(tline);
3061             free_tlist(origline);
3062             return DIRECTIVE_FOUND;
3063         }
3064
3065         nasm_unquote_cstr(t->text, i);
3066         macro_start = tokenize(t->text);
3067
3068         /*
3069          * We now have a macro name, an implicit parameter count of
3070          * zero, and a numeric token to use as an expansion. Create
3071          * and store an SMacro.
3072          */
3073         define_smacro(ctx, mname, casesense, 0, macro_start);
3074         free_tlist(tline);
3075         free_tlist(origline);
3076         return DIRECTIVE_FOUND;
3077
3078     case PP_PATHSEARCH:
3079     {
3080         FILE *fp;
3081         StrList *xsl = NULL;
3082         StrList **xst = &xsl;
3083
3084         casesense = true;
3085
3086         tline = tline->next;
3087         skip_white_(tline);
3088         tline = expand_id(tline);
3089         if (!tline || (tline->type != TOK_ID &&
3090                        (tline->type != TOK_PREPROC_ID ||
3091                         tline->text[1] != '$'))) {
3092             error(ERR_NONFATAL,
3093                   "`%%pathsearch' expects a macro identifier as first parameter");
3094             free_tlist(origline);
3095             return DIRECTIVE_FOUND;
3096         }
3097         ctx = get_ctx(tline->text, &mname, false);
3098         last = tline;
3099         tline = expand_smacro(tline->next);
3100         last->next = NULL;
3101
3102         t = tline;
3103         while (tok_type_(t, TOK_WHITESPACE))
3104             t = t->next;
3105
3106         if (!t || (t->type != TOK_STRING &&
3107                    t->type != TOK_INTERNAL_STRING)) {
3108             error(ERR_NONFATAL, "`%%pathsearch' expects a file name");
3109             free_tlist(tline);
3110             free_tlist(origline);
3111             return DIRECTIVE_FOUND;     /* but we did _something_ */
3112         }
3113         if (t->next)
3114             error(ERR_WARNING|ERR_PASS1,
3115                   "trailing garbage after `%%pathsearch' ignored");
3116         p = t->text;
3117         if (t->type != TOK_INTERNAL_STRING)
3118             nasm_unquote(p, NULL);
3119
3120         fp = inc_fopen(p, &xsl, &xst, true);
3121         if (fp) {
3122             p = xsl->str;
3123             fclose(fp);         /* Don't actually care about the file */
3124         }
3125         macro_start = nasm_malloc(sizeof(*macro_start));
3126         macro_start->next = NULL;
3127         macro_start->text = nasm_quote(p, strlen(p));
3128         macro_start->type = TOK_STRING;
3129         macro_start->a.mac = NULL;
3130         if (xsl)
3131             nasm_free(xsl);
3132
3133         /*
3134          * We now have a macro name, an implicit parameter count of
3135          * zero, and a string token to use as an expansion. Create
3136          * and store an SMacro.
3137          */
3138         define_smacro(ctx, mname, casesense, 0, macro_start);
3139         free_tlist(tline);
3140         free_tlist(origline);
3141         return DIRECTIVE_FOUND;
3142     }
3143
3144     case PP_STRLEN:
3145         casesense = true;
3146
3147         tline = tline->next;
3148         skip_white_(tline);
3149         tline = expand_id(tline);
3150         if (!tline || (tline->type != TOK_ID &&
3151                        (tline->type != TOK_PREPROC_ID ||
3152                         tline->text[1] != '$'))) {
3153             error(ERR_NONFATAL,
3154                   "`%%strlen' expects a macro identifier as first parameter");
3155             free_tlist(origline);
3156             return DIRECTIVE_FOUND;
3157         }
3158         ctx = get_ctx(tline->text, &mname, false);
3159         last = tline;
3160         tline = expand_smacro(tline->next);
3161         last->next = NULL;
3162
3163         t = tline;
3164         while (tok_type_(t, TOK_WHITESPACE))
3165             t = t->next;
3166         /* t should now point to the string */
3167         if (t->type != TOK_STRING) {
3168             error(ERR_NONFATAL,
3169                   "`%%strlen` requires string as second parameter");
3170             free_tlist(tline);
3171             free_tlist(origline);
3172             return DIRECTIVE_FOUND;
3173         }
3174
3175         macro_start = nasm_malloc(sizeof(*macro_start));
3176         macro_start->next = NULL;
3177         make_tok_num(macro_start, nasm_unquote(t->text, NULL));
3178         macro_start->a.mac = NULL;
3179
3180         /*
3181          * We now have a macro name, an implicit parameter count of
3182          * zero, and a numeric token to use as an expansion. Create
3183          * and store an SMacro.
3184          */
3185         define_smacro(ctx, mname, casesense, 0, macro_start);
3186         free_tlist(tline);
3187         free_tlist(origline);
3188         return DIRECTIVE_FOUND;
3189
3190     case PP_STRCAT:
3191         casesense = true;
3192
3193         tline = tline->next;
3194         skip_white_(tline);
3195         tline = expand_id(tline);
3196         if (!tline || (tline->type != TOK_ID &&
3197                        (tline->type != TOK_PREPROC_ID ||
3198                         tline->text[1] != '$'))) {
3199             error(ERR_NONFATAL,
3200                   "`%%strcat' expects a macro identifier as first parameter");
3201             free_tlist(origline);
3202             return DIRECTIVE_FOUND;
3203         }
3204         ctx = get_ctx(tline->text, &mname, false);
3205         last = tline;
3206         tline = expand_smacro(tline->next);
3207         last->next = NULL;
3208
3209         len = 0;
3210         for (t = tline; t; t = t->next) {
3211             switch (t->type) {
3212             case TOK_WHITESPACE:
3213                 break;
3214             case TOK_STRING:
3215                 len += t->a.len = nasm_unquote(t->text, NULL);
3216                 break;
3217             case TOK_OTHER:
3218                 if (!strcmp(t->text, ",")) /* permit comma separators */
3219                     break;
3220                 /* else fall through */
3221             default:
3222                 error(ERR_NONFATAL,
3223                       "non-string passed to `%%strcat' (%d)", t->type);
3224                 free_tlist(tline);
3225                 free_tlist(origline);
3226                 return DIRECTIVE_FOUND;
3227             }
3228         }
3229
3230         p = pp = nasm_malloc(len);
3231         for (t = tline; t; t = t->next) {
3232             if (t->type == TOK_STRING) {
3233                 memcpy(p, t->text, t->a.len);
3234                 p += t->a.len;
3235             }
3236         }
3237
3238         /*
3239          * We now have a macro name, an implicit parameter count of
3240          * zero, and a numeric token to use as an expansion. Create
3241          * and store an SMacro.
3242          */
3243         macro_start = new_Token(NULL, TOK_STRING, NULL, 0);
3244         macro_start->text = nasm_quote(pp, len);
3245         nasm_free(pp);
3246         define_smacro(ctx, mname, casesense, 0, macro_start);
3247         free_tlist(tline);
3248         free_tlist(origline);
3249         return DIRECTIVE_FOUND;
3250
3251     case PP_SUBSTR:
3252     {
3253         int64_t a1, a2;
3254         size_t len;
3255
3256         casesense = true;
3257
3258         tline = tline->next;
3259         skip_white_(tline);
3260         tline = expand_id(tline);
3261         if (!tline || (tline->type != TOK_ID &&
3262                        (tline->type != TOK_PREPROC_ID ||
3263                         tline->text[1] != '$'))) {
3264             error(ERR_NONFATAL,
3265                   "`%%substr' expects a macro identifier as first parameter");
3266             free_tlist(origline);
3267             return DIRECTIVE_FOUND;
3268         }
3269         ctx = get_ctx(tline->text, &mname, false);
3270         last = tline;
3271         tline = expand_smacro(tline->next);
3272         last->next = NULL;
3273
3274         t = tline->next;
3275         while (tok_type_(t, TOK_WHITESPACE))
3276             t = t->next;
3277
3278         /* t should now point to the string */
3279         if (t->type != TOK_STRING) {
3280             error(ERR_NONFATAL,
3281                   "`%%substr` requires string as second parameter");
3282             free_tlist(tline);
3283             free_tlist(origline);
3284             return DIRECTIVE_FOUND;
3285         }
3286
3287         tt = t->next;
3288         tptr = &tt;
3289         tokval.t_type = TOKEN_INVALID;
3290         evalresult = evaluate(ppscan, tptr, &tokval, NULL,
3291                               pass, error, NULL);
3292         if (!evalresult) {
3293             free_tlist(tline);
3294             free_tlist(origline);
3295             return DIRECTIVE_FOUND;
3296         } else if (!is_simple(evalresult)) {
3297             error(ERR_NONFATAL, "non-constant value given to `%%substr`");
3298             free_tlist(tline);
3299             free_tlist(origline);
3300             return DIRECTIVE_FOUND;
3301         }
3302         a1 = evalresult->value-1;
3303
3304         while (tok_type_(tt, TOK_WHITESPACE))
3305             tt = tt->next;
3306         if (!tt) {
3307             a2 = 1;             /* Backwards compatibility: one character */
3308         } else {
3309             tokval.t_type = TOKEN_INVALID;
3310             evalresult = evaluate(ppscan, tptr, &tokval, NULL,
3311                                   pass, error, NULL);
3312             if (!evalresult) {
3313                 free_tlist(tline);
3314                 free_tlist(origline);
3315                 return DIRECTIVE_FOUND;
3316             } else if (!is_simple(evalresult)) {
3317                 error(ERR_NONFATAL, "non-constant value given to `%%substr`");
3318                 free_tlist(tline);
3319                 free_tlist(origline);
3320                 return DIRECTIVE_FOUND;
3321             }
3322             a2 = evalresult->value;
3323         }
3324
3325         len = nasm_unquote(t->text, NULL);
3326         if (a2 < 0)
3327             a2 = a2+1+len-a1;
3328         if (a1+a2 > (int64_t)len)
3329             a2 = len-a1;
3330
3331         macro_start = nasm_malloc(sizeof(*macro_start));
3332         macro_start->next = NULL;
3333         macro_start->text = nasm_quote((a1 < 0) ? "" : t->text+a1, a2);
3334         macro_start->type = TOK_STRING;
3335         macro_start->a.mac = NULL;
3336
3337         /*
3338          * We now have a macro name, an implicit parameter count of
3339          * zero, and a numeric token to use as an expansion. Create
3340          * and store an SMacro.
3341          */
3342         define_smacro(ctx, mname, casesense, 0, macro_start);
3343         free_tlist(tline);
3344         free_tlist(origline);
3345         return DIRECTIVE_FOUND;
3346     }
3347
3348     case PP_ASSIGN:
3349     case PP_IASSIGN:
3350         casesense = (i == PP_ASSIGN);
3351
3352         tline = tline->next;
3353         skip_white_(tline);
3354         tline = expand_id(tline);
3355         if (!tline || (tline->type != TOK_ID &&
3356                        (tline->type != TOK_PREPROC_ID ||
3357                         tline->text[1] != '$'))) {
3358             error(ERR_NONFATAL,
3359                   "`%%%sassign' expects a macro identifier",
3360                   (i == PP_IASSIGN ? "i" : ""));
3361             free_tlist(origline);
3362             return DIRECTIVE_FOUND;
3363         }
3364         ctx = get_ctx(tline->text, &mname, false);
3365         last = tline;
3366         tline = expand_smacro(tline->next);
3367         last->next = NULL;
3368
3369         t = tline;
3370         tptr = &t;
3371         tokval.t_type = TOKEN_INVALID;
3372         evalresult =
3373             evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
3374         free_tlist(tline);
3375         if (!evalresult) {
3376             free_tlist(origline);
3377             return DIRECTIVE_FOUND;
3378         }
3379
3380         if (tokval.t_type)
3381             error(ERR_WARNING|ERR_PASS1,
3382                   "trailing garbage after expression ignored");
3383
3384         if (!is_simple(evalresult)) {
3385             error(ERR_NONFATAL,
3386                   "non-constant value given to `%%%sassign'",
3387                   (i == PP_IASSIGN ? "i" : ""));
3388             free_tlist(origline);
3389             return DIRECTIVE_FOUND;
3390         }
3391
3392         macro_start = nasm_malloc(sizeof(*macro_start));
3393         macro_start->next = NULL;
3394         make_tok_num(macro_start, reloc_value(evalresult));
3395         macro_start->a.mac = NULL;
3396
3397         /*
3398          * We now have a macro name, an implicit parameter count of
3399          * zero, and a numeric token to use as an expansion. Create
3400          * and store an SMacro.
3401          */
3402         define_smacro(ctx, mname, casesense, 0, macro_start);
3403         free_tlist(origline);
3404         return DIRECTIVE_FOUND;
3405
3406     case PP_LINE:
3407         /*
3408          * Syntax is `%line nnn[+mmm] [filename]'
3409          */
3410         tline = tline->next;
3411         skip_white_(tline);
3412         if (!tok_type_(tline, TOK_NUMBER)) {
3413             error(ERR_NONFATAL, "`%%line' expects line number");
3414             free_tlist(origline);
3415             return DIRECTIVE_FOUND;
3416         }
3417         k = readnum(tline->text, &err);
3418         m = 1;
3419         tline = tline->next;
3420         if (tok_is_(tline, "+")) {
3421             tline = tline->next;
3422             if (!tok_type_(tline, TOK_NUMBER)) {
3423                 error(ERR_NONFATAL, "`%%line' expects line increment");
3424                 free_tlist(origline);
3425                 return DIRECTIVE_FOUND;
3426             }
3427             m = readnum(tline->text, &err);
3428             tline = tline->next;
3429         }
3430         skip_white_(tline);
3431         src_set_linnum(k);
3432         istk->lineinc = m;
3433         if (tline) {
3434             nasm_free(src_set_fname(detoken(tline, false)));
3435         }
3436         free_tlist(origline);
3437         return DIRECTIVE_FOUND;
3438
3439     default:
3440         error(ERR_FATAL,
3441               "preprocessor directive `%s' not yet implemented",
3442               pp_directives[i]);
3443         return DIRECTIVE_FOUND;
3444     }
3445 }
3446
3447 /*
3448  * Ensure that a macro parameter contains a condition code and
3449  * nothing else. Return the condition code index if so, or -1
3450  * otherwise.
3451  */
3452 static int find_cc(Token * t)
3453 {
3454     Token *tt;
3455     int i, j, k, m;
3456
3457     if (!t)
3458         return -1;              /* Probably a %+ without a space */
3459
3460     skip_white_(t);
3461     if (t->type != TOK_ID)
3462         return -1;
3463     tt = t->next;
3464     skip_white_(tt);
3465     if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
3466         return -1;
3467
3468     i = -1;
3469     j = elements(conditions);
3470     while (j - i > 1) {
3471         k = (j + i) / 2;
3472         m = nasm_stricmp(t->text, conditions[k]);
3473         if (m == 0) {
3474             i = k;
3475             j = -2;
3476             break;
3477         } else if (m < 0) {
3478             j = k;
3479         } else
3480             i = k;
3481     }
3482     if (j != -2)
3483         return -1;
3484     return i;
3485 }
3486
3487 static bool paste_tokens(Token **head, bool handle_paste_tokens)
3488 {
3489     Token **tail, *t, *tt;
3490     Token **paste_head;
3491     bool did_paste = false;
3492     char *tmp;
3493
3494     /* Now handle token pasting... */
3495     paste_head = NULL;
3496     tail = head;
3497     while ((t = *tail) && (tt = t->next)) {
3498         switch (t->type) {
3499         case TOK_WHITESPACE:
3500             if (tt->type == TOK_WHITESPACE) {
3501                 /* Zap adjacent whitespace tokens */
3502                 t->next = delete_Token(tt);
3503             } else {
3504                 /* Do not advance paste_head here */
3505                 tail = &t->next;
3506             }
3507             break;
3508         case TOK_ID:
3509         case TOK_PREPROC_ID:
3510         case TOK_NUMBER:
3511         case TOK_FLOAT:
3512         {
3513             size_t len = 0;
3514             char *tmp, *p;
3515
3516             while (tt && (tt->type == TOK_ID || tt->type == TOK_PREPROC_ID ||
3517                           tt->type == TOK_NUMBER || tt->type == TOK_FLOAT ||
3518                           tt->type == TOK_OTHER)) {
3519                 len += strlen(tt->text);
3520                 tt = tt->next;
3521             }
3522
3523             /*
3524              * Now tt points to the first token after
3525              * the potential paste area...
3526              */
3527             if (tt != t->next) {
3528                 /* We have at least two tokens... */
3529                 len += strlen(t->text);
3530                 p = tmp = nasm_malloc(len+1);
3531
3532                 while (t != tt) {
3533                     strcpy(p, t->text);
3534                     p = strchr(p, '\0');
3535                     t = delete_Token(t);
3536                 }
3537
3538                 t = *tail = tokenize(tmp);
3539                 nasm_free(tmp);
3540
3541                 while (t->next) {
3542                     tail = &t->next;
3543                     t = t->next;
3544                 }
3545                 t->next = tt;   /* Attach the remaining token chain */
3546
3547                 did_paste = true;
3548             }
3549             paste_head = tail;
3550             tail = &t->next;
3551             break;
3552         }
3553         case TOK_PASTE:         /* %+ */
3554             if (handle_paste_tokens) {
3555                 /* Zap %+ and whitespace tokens to the right */
3556                 while (t && (t->type == TOK_WHITESPACE ||
3557                              t->type == TOK_PASTE))
3558                     t = *tail = delete_Token(t);
3559                 if (!paste_head || !t)
3560                     break;      /* Nothing to paste with */
3561                 tail = paste_head;
3562                 t = *tail;
3563                 tt = t->next;
3564                 while (tok_type_(tt, TOK_WHITESPACE))
3565                     tt = t->next = delete_Token(tt);
3566
3567                 if (tt) {
3568                     tmp = nasm_strcat(t->text, tt->text);
3569                     delete_Token(t);
3570                     tt = delete_Token(tt);
3571                     t = *tail = tokenize(tmp);
3572                     nasm_free(tmp);
3573                     while (t->next) {
3574                         tail = &t->next;
3575                         t = t->next;
3576                     }
3577                     t->next = tt; /* Attach the remaining token chain */
3578                     did_paste = true;
3579                 }
3580                 paste_head = tail;
3581                 tail = &t->next;
3582                 break;
3583             }
3584             /* else fall through */
3585         default:
3586             tail = paste_head = &t->next;
3587             break;
3588         }
3589     }
3590     return did_paste;
3591 }
3592 /*
3593  * Expand MMacro-local things: parameter references (%0, %n, %+n,
3594  * %-n) and MMacro-local identifiers (%%foo) as well as
3595  * macro indirection (%[...]).
3596  */
3597 static Token *expand_mmac_params(Token * tline)
3598 {
3599     Token *t, *tt, **tail, *thead;
3600     bool changed = false;
3601
3602     tail = &thead;
3603     thead = NULL;
3604
3605     while (tline) {
3606         if (tline->type == TOK_PREPROC_ID &&
3607             (((tline->text[1] == '+' || tline->text[1] == '-')
3608               && tline->text[2]) || tline->text[1] == '%'
3609              || (tline->text[1] >= '0' && tline->text[1] <= '9'))) {
3610             char *text = NULL;
3611             int type = 0, cc;   /* type = 0 to placate optimisers */
3612             char tmpbuf[30];
3613             unsigned int n;
3614             int i;
3615             MMacro *mac;
3616
3617             t = tline;
3618             tline = tline->next;
3619
3620             mac = istk->mstk;
3621             while (mac && !mac->name)   /* avoid mistaking %reps for macros */
3622                 mac = mac->next_active;
3623             if (!mac)
3624                 error(ERR_NONFATAL, "`%s': not in a macro call", t->text);
3625             else
3626                 switch (t->text[1]) {
3627                     /*
3628                      * We have to make a substitution of one of the
3629                      * forms %1, %-1, %+1, %%foo, %0.
3630                      */
3631                 case '0':
3632                     type = TOK_NUMBER;
3633                     snprintf(tmpbuf, sizeof(tmpbuf), "%d", mac->nparam);
3634                     text = nasm_strdup(tmpbuf);
3635                     break;
3636                 case '%':
3637                     type = TOK_ID;
3638                     snprintf(tmpbuf, sizeof(tmpbuf), "..@%"PRIu64".",
3639                              mac->unique);
3640                     text = nasm_strcat(tmpbuf, t->text + 2);
3641                     break;
3642                 case '-':
3643                     n = atoi(t->text + 2) - 1;
3644                     if (n >= mac->nparam)
3645                         tt = NULL;
3646                     else {
3647                         if (mac->nparam > 1)
3648                             n = (n + mac->rotate) % mac->nparam;
3649                         tt = mac->params[n];
3650                     }
3651                     cc = find_cc(tt);
3652                     if (cc == -1) {
3653                         error(ERR_NONFATAL,
3654                               "macro parameter %d is not a condition code",
3655                               n + 1);
3656                         text = NULL;
3657                     } else {
3658                         type = TOK_ID;
3659                         if (inverse_ccs[cc] == -1) {
3660                             error(ERR_NONFATAL,
3661                                   "condition code `%s' is not invertible",
3662                                   conditions[cc]);
3663                             text = NULL;
3664                         } else
3665                             text = nasm_strdup(conditions[inverse_ccs[cc]]);
3666                     }
3667                     break;
3668                 case '+':
3669                     n = atoi(t->text + 2) - 1;
3670                     if (n >= mac->nparam)
3671                         tt = NULL;
3672                     else {
3673                         if (mac->nparam > 1)
3674                             n = (n + mac->rotate) % mac->nparam;
3675                         tt = mac->params[n];
3676                     }
3677                     cc = find_cc(tt);
3678                     if (cc == -1) {
3679                         error(ERR_NONFATAL,
3680                               "macro parameter %d is not a condition code",
3681                               n + 1);
3682                         text = NULL;
3683                     } else {
3684                         type = TOK_ID;
3685                         text = nasm_strdup(conditions[cc]);
3686                     }
3687                     break;
3688                 default:
3689                     n = atoi(t->text + 1) - 1;
3690                     if (n >= mac->nparam)
3691                         tt = NULL;
3692                     else {
3693                         if (mac->nparam > 1)
3694                             n = (n + mac->rotate) % mac->nparam;
3695                         tt = mac->params[n];
3696                     }
3697                     if (tt) {
3698                         for (i = 0; i < mac->paramlen[n]; i++) {
3699                             *tail = new_Token(NULL, tt->type, tt->text, 0);
3700                             tail = &(*tail)->next;
3701                             tt = tt->next;
3702                         }
3703                     }
3704                     text = NULL;        /* we've done it here */
3705                     break;
3706                 }
3707             if (!text) {
3708                 delete_Token(t);
3709             } else {
3710                 *tail = t;
3711                 tail = &t->next;
3712                 t->type = type;
3713                 nasm_free(t->text);
3714                 t->text = text;
3715                 t->a.mac = NULL;
3716             }
3717             changed = true;
3718             continue;
3719         } else if (tline->type == TOK_INDIRECT) {
3720             t = tline;
3721             tline = tline->next;
3722             tt = tokenize(t->text);
3723             tt = expand_mmac_params(tt);
3724             tt = expand_smacro(tt);
3725             *tail = tt;
3726             while (tt) {
3727                 tt->a.mac = NULL; /* Necessary? */
3728                 tail = &tt->next;
3729                 tt = tt->next;
3730             }
3731             delete_Token(t);
3732             changed = true;
3733         } else {
3734             t = *tail = tline;
3735             tline = tline->next;
3736             t->a.mac = NULL;
3737             tail = &t->next;
3738         }
3739     }
3740     *tail = NULL;
3741
3742     if (changed)
3743         paste_tokens(&thead, false);
3744
3745     return thead;
3746 }
3747
3748 /*
3749  * Expand all single-line macro calls made in the given line.
3750  * Return the expanded version of the line. The original is deemed
3751  * to be destroyed in the process. (In reality we'll just move
3752  * Tokens from input to output a lot of the time, rather than
3753  * actually bothering to destroy and replicate.)
3754  */
3755
3756 static Token *expand_smacro(Token * tline)
3757 {
3758     Token *t, *tt, *mstart, **tail, *thead;
3759     SMacro *head = NULL, *m;
3760     Token **params;
3761     int *paramsize;
3762     unsigned int nparam, sparam;
3763     int brackets;
3764     Token *org_tline = tline;
3765     Context *ctx;
3766     const char *mname;
3767     int deadman = DEADMAN_LIMIT;
3768     bool expanded;
3769
3770     /*
3771      * Trick: we should avoid changing the start token pointer since it can
3772      * be contained in "next" field of other token. Because of this
3773      * we allocate a copy of first token and work with it; at the end of
3774      * routine we copy it back
3775      */
3776     if (org_tline) {
3777         tline =
3778             new_Token(org_tline->next, org_tline->type, org_tline->text,
3779                       0);
3780         tline->a.mac = org_tline->a.mac;
3781         nasm_free(org_tline->text);
3782         org_tline->text = NULL;
3783     }
3784
3785     expanded = true;            /* Always expand %+ at least once */
3786
3787 again:
3788     tail = &thead;
3789     thead = NULL;
3790
3791     while (tline) {             /* main token loop */
3792         if (!--deadman) {
3793             error(ERR_NONFATAL, "interminable macro recursion");
3794             goto err;
3795         }
3796
3797         if ((mname = tline->text)) {
3798             /* if this token is a local macro, look in local context */
3799             if (tline->type == TOK_ID) {
3800                 head = (SMacro *)hash_findix(&smacros, mname);
3801             } else if (tline->type == TOK_PREPROC_ID) {
3802                 ctx = get_ctx(mname, &mname, true);
3803                 head = ctx ? (SMacro *)hash_findix(&ctx->localmac, mname) : NULL;
3804             } else
3805                 head = NULL;
3806
3807             /*
3808              * We've hit an identifier. As in is_mmacro below, we first
3809              * check whether the identifier is a single-line macro at
3810              * all, then think about checking for parameters if
3811              * necessary.
3812              */
3813             for (m = head; m; m = m->next)
3814                 if (!mstrcmp(m->name, mname, m->casesense))
3815                     break;
3816             if (m) {
3817                 mstart = tline;
3818                 params = NULL;
3819                 paramsize = NULL;
3820                 if (m->nparam == 0) {
3821                     /*
3822                      * Simple case: the macro is parameterless. Discard the
3823                      * one token that the macro call took, and push the
3824                      * expansion back on the to-do stack.
3825                      */
3826                     if (!m->expansion) {
3827                         if (!strcmp("__FILE__", m->name)) {
3828                             int32_t num = 0;
3829                             char *file = NULL;
3830                             src_get(&num, &file);
3831                             tline->text = nasm_quote(file, strlen(file));
3832                             tline->type = TOK_STRING;
3833                             nasm_free(file);
3834                             continue;
3835                         }
3836                         if (!strcmp("__LINE__", m->name)) {
3837                             nasm_free(tline->text);
3838                             make_tok_num(tline, src_get_linnum());
3839                             continue;
3840                         }
3841                         if (!strcmp("__BITS__", m->name)) {
3842                             nasm_free(tline->text);
3843                             make_tok_num(tline, globalbits);
3844                             continue;
3845                         }
3846                         tline = delete_Token(tline);
3847                         continue;
3848                     }
3849                 } else {
3850                     /*
3851                      * Complicated case: at least one macro with this name
3852                      * exists and takes parameters. We must find the
3853                      * parameters in the call, count them, find the SMacro
3854                      * that corresponds to that form of the macro call, and
3855                      * substitute for the parameters when we expand. What a
3856                      * pain.
3857                      */
3858                     /*tline = tline->next;
3859                       skip_white_(tline); */
3860                     do {
3861                         t = tline->next;
3862                         while (tok_type_(t, TOK_SMAC_END)) {
3863                             t->a.mac->in_progress = false;
3864                             t->text = NULL;
3865                             t = tline->next = delete_Token(t);
3866                         }
3867                         tline = t;
3868                     } while (tok_type_(tline, TOK_WHITESPACE));
3869                     if (!tok_is_(tline, "(")) {
3870                         /*
3871                          * This macro wasn't called with parameters: ignore
3872                          * the call. (Behaviour borrowed from gnu cpp.)
3873                          */
3874                         tline = mstart;
3875                         m = NULL;
3876                     } else {
3877                         int paren = 0;
3878                         int white = 0;
3879                         brackets = 0;
3880                         nparam = 0;
3881                         sparam = PARAM_DELTA;
3882                         params = nasm_malloc(sparam * sizeof(Token *));
3883                         params[0] = tline->next;
3884                         paramsize = nasm_malloc(sparam * sizeof(int));
3885                         paramsize[0] = 0;
3886                         while (true) {  /* parameter loop */
3887                             /*
3888                              * For some unusual expansions
3889                              * which concatenates function call
3890                              */
3891                             t = tline->next;
3892                             while (tok_type_(t, TOK_SMAC_END)) {
3893                                 t->a.mac->in_progress = false;
3894                                 t->text = NULL;
3895                                 t = tline->next = delete_Token(t);
3896                             }
3897                             tline = t;
3898
3899                             if (!tline) {
3900                                 error(ERR_NONFATAL,
3901                                       "macro call expects terminating `)'");
3902                                 break;
3903                             }
3904                             if (tline->type == TOK_WHITESPACE
3905                                 && brackets <= 0) {
3906                                 if (paramsize[nparam])
3907                                     white++;
3908                                 else
3909                                     params[nparam] = tline->next;
3910                                 continue;       /* parameter loop */
3911                             }
3912                             if (tline->type == TOK_OTHER
3913                                 && tline->text[1] == 0) {
3914                                 char ch = tline->text[0];
3915                                 if (ch == ',' && !paren && brackets <= 0) {
3916                                     if (++nparam >= sparam) {
3917                                         sparam += PARAM_DELTA;
3918                                         params = nasm_realloc(params,
3919                                                               sparam *
3920                                                               sizeof(Token
3921                                                                      *));
3922                                         paramsize =
3923                                             nasm_realloc(paramsize,
3924                                                          sparam *
3925                                                          sizeof(int));
3926                                     }
3927                                     params[nparam] = tline->next;
3928                                     paramsize[nparam] = 0;
3929                                     white = 0;
3930                                     continue;   /* parameter loop */
3931                                 }
3932                                 if (ch == '{' &&
3933                                     (brackets > 0 || (brackets == 0 &&
3934                                                       !paramsize[nparam])))
3935                                 {
3936                                     if (!(brackets++)) {
3937                                         params[nparam] = tline->next;
3938                                         continue;       /* parameter loop */
3939                                     }
3940                                 }
3941                                 if (ch == '}' && brackets > 0)
3942                                     if (--brackets == 0) {
3943                                         brackets = -1;
3944                                         continue;       /* parameter loop */
3945                                     }
3946                                 if (ch == '(' && !brackets)
3947                                     paren++;
3948                                 if (ch == ')' && brackets <= 0)
3949                                     if (--paren < 0)
3950                                         break;
3951                             }
3952                             if (brackets < 0) {
3953                                 brackets = 0;
3954                                 error(ERR_NONFATAL, "braces do not "
3955                                       "enclose all of macro parameter");
3956                             }
3957                             paramsize[nparam] += white + 1;
3958                             white = 0;
3959                         }       /* parameter loop */
3960                         nparam++;
3961                         while (m && (m->nparam != nparam ||
3962                                      mstrcmp(m->name, mname,
3963                                              m->casesense)))
3964                             m = m->next;
3965                         if (!m)
3966                             error(ERR_WARNING|ERR_PASS1|ERR_WARN_MNP,
3967                                   "macro `%s' exists, "
3968                                   "but not taking %d parameters",
3969                                   mstart->text, nparam);
3970                     }
3971                 }
3972                 if (m && m->in_progress)
3973                     m = NULL;
3974                 if (!m) {       /* in progess or didn't find '(' or wrong nparam */
3975                     /*
3976                      * Design question: should we handle !tline, which
3977                      * indicates missing ')' here, or expand those
3978                      * macros anyway, which requires the (t) test a few
3979                      * lines down?
3980                      */
3981                     nasm_free(params);
3982                     nasm_free(paramsize);
3983                     tline = mstart;
3984                 } else {
3985                     /*
3986                      * Expand the macro: we are placed on the last token of the
3987                      * call, so that we can easily split the call from the
3988                      * following tokens. We also start by pushing an SMAC_END
3989                      * token for the cycle removal.
3990                      */
3991                     t = tline;
3992                     if (t) {
3993                         tline = t->next;
3994                         t->next = NULL;
3995                     }
3996                     tt = new_Token(tline, TOK_SMAC_END, NULL, 0);
3997                     tt->a.mac = m;
3998                     m->in_progress = true;
3999                     tline = tt;
4000                     for (t = m->expansion; t; t = t->next) {
4001                         if (t->type >= TOK_SMAC_PARAM) {
4002                             Token *pcopy = tline, **ptail = &pcopy;
4003                             Token *ttt, *pt;
4004                             int i;
4005
4006                             ttt = params[t->type - TOK_SMAC_PARAM];
4007                             for (i = paramsize[t->type - TOK_SMAC_PARAM];
4008                                  --i >= 0;) {
4009                                 pt = *ptail =
4010                                     new_Token(tline, ttt->type, ttt->text,
4011                                               0);
4012                                 ptail = &pt->next;
4013                                 ttt = ttt->next;
4014                             }
4015                             tline = pcopy;
4016                         } else if (t->type == TOK_PREPROC_Q) {
4017                             tt = new_Token(tline, TOK_ID, mname, 0);
4018                             tline = tt;
4019                         } else if (t->type == TOK_PREPROC_QQ) {
4020                             tt = new_Token(tline, TOK_ID, m->name, 0);
4021                             tline = tt;
4022                         } else {
4023                             tt = new_Token(tline, t->type, t->text, 0);
4024                             tline = tt;
4025                         }
4026                     }
4027
4028                     /*
4029                      * Having done that, get rid of the macro call, and clean
4030                      * up the parameters.
4031                      */
4032                     nasm_free(params);
4033                     nasm_free(paramsize);
4034                     free_tlist(mstart);
4035                     expanded = true;
4036                     continue;   /* main token loop */
4037                 }
4038             }
4039         }
4040
4041         if (tline->type == TOK_SMAC_END) {
4042             tline->a.mac->in_progress = false;
4043             tline = delete_Token(tline);
4044         } else {
4045             t = *tail = tline;
4046             tline = tline->next;
4047             t->a.mac = NULL;
4048             t->next = NULL;
4049             tail = &t->next;
4050         }
4051     }
4052
4053     /*
4054      * Now scan the entire line and look for successive TOK_IDs that resulted
4055      * after expansion (they can't be produced by tokenize()). The successive
4056      * TOK_IDs should be concatenated.
4057      * Also we look for %+ tokens and concatenate the tokens before and after
4058      * them (without white spaces in between).
4059      */
4060     if (expanded && paste_tokens(&thead, true)) {
4061         /*
4062          * If we concatenated something, *and* we had previously expanded
4063          * an actual macro, scan the lines again for macros...
4064          */
4065         tline = thead;
4066         expanded = false;
4067         goto again;
4068     }
4069
4070 err:
4071     if (org_tline) {
4072         if (thead) {
4073             *org_tline = *thead;
4074             /* since we just gave text to org_line, don't free it */
4075             thead->text = NULL;
4076             delete_Token(thead);
4077         } else {
4078             /* the expression expanded to empty line;
4079                we can't return NULL for some reasons
4080                we just set the line to a single WHITESPACE token. */
4081             memset(org_tline, 0, sizeof(*org_tline));
4082             org_tline->text = NULL;
4083             org_tline->type = TOK_WHITESPACE;
4084         }
4085         thead = org_tline;
4086     }
4087
4088     return thead;
4089 }
4090
4091 /*
4092  * Similar to expand_smacro but used exclusively with macro identifiers
4093  * right before they are fetched in. The reason is that there can be
4094  * identifiers consisting of several subparts. We consider that if there
4095  * are more than one element forming the name, user wants a expansion,
4096  * otherwise it will be left as-is. Example:
4097  *
4098  *      %define %$abc cde
4099  *
4100  * the identifier %$abc will be left as-is so that the handler for %define
4101  * will suck it and define the corresponding value. Other case:
4102  *
4103  *      %define _%$abc cde
4104  *
4105  * In this case user wants name to be expanded *before* %define starts
4106  * working, so we'll expand %$abc into something (if it has a value;
4107  * otherwise it will be left as-is) then concatenate all successive
4108  * PP_IDs into one.
4109  */
4110 static Token *expand_id(Token * tline)
4111 {
4112     Token *cur, *oldnext = NULL;
4113
4114     if (!tline || !tline->next)
4115         return tline;
4116
4117     cur = tline;
4118     while (cur->next &&
4119            (cur->next->type == TOK_ID ||
4120             cur->next->type == TOK_PREPROC_ID
4121             || cur->next->type == TOK_NUMBER))
4122         cur = cur->next;
4123
4124     /* If identifier consists of just one token, don't expand */
4125     if (cur == tline)
4126         return tline;
4127
4128     if (cur) {
4129         oldnext = cur->next;    /* Detach the tail past identifier */
4130         cur->next = NULL;       /* so that expand_smacro stops here */
4131     }
4132
4133     tline = expand_smacro(tline);
4134
4135     if (cur) {
4136         /* expand_smacro possibly changhed tline; re-scan for EOL */
4137         cur = tline;
4138         while (cur && cur->next)
4139             cur = cur->next;
4140         if (cur)
4141             cur->next = oldnext;
4142     }
4143
4144     return tline;
4145 }
4146
4147 /*
4148  * Determine whether the given line constitutes a multi-line macro
4149  * call, and return the MMacro structure called if so. Doesn't have
4150  * to check for an initial label - that's taken care of in
4151  * expand_mmacro - but must check numbers of parameters. Guaranteed
4152  * to be called with tline->type == TOK_ID, so the putative macro
4153  * name is easy to find.
4154  */
4155 static MMacro *is_mmacro(Token * tline, Token *** params_array)
4156 {
4157     MMacro *head, *m;
4158     Token **params;
4159     int nparam;
4160
4161     head = (MMacro *) hash_findix(&mmacros, tline->text);
4162
4163     /*
4164      * Efficiency: first we see if any macro exists with the given
4165      * name. If not, we can return NULL immediately. _Then_ we
4166      * count the parameters, and then we look further along the
4167      * list if necessary to find the proper MMacro.
4168      */
4169     for (m = head; m; m = m->next)
4170         if (!mstrcmp(m->name, tline->text, m->casesense))
4171             break;
4172     if (!m)
4173         return NULL;
4174
4175     /*
4176      * OK, we have a potential macro. Count and demarcate the
4177      * parameters.
4178      */
4179     count_mmac_params(tline->next, &nparam, &params);
4180
4181     /*
4182      * So we know how many parameters we've got. Find the MMacro
4183      * structure that handles this number.
4184      */
4185     while (m) {
4186         if (m->nparam_min <= nparam
4187             && (m->plus || nparam <= m->nparam_max)) {
4188             /*
4189              * This one is right. Just check if cycle removal
4190              * prohibits us using it before we actually celebrate...
4191              */
4192             if (m->in_progress > m->max_depth) {
4193                 if (m->max_depth > 0) {
4194                     error(ERR_WARNING,
4195                           "reached maximum recursion depth of %i",
4196                           m->max_depth);
4197                 }
4198                 nasm_free(params);
4199                 return NULL;
4200             }
4201             /*
4202              * It's right, and we can use it. Add its default
4203              * parameters to the end of our list if necessary.
4204              */
4205             if (m->defaults && nparam < m->nparam_min + m->ndefs) {
4206                 params =
4207                     nasm_realloc(params,
4208                                  ((m->nparam_min + m->ndefs +
4209                                    1) * sizeof(*params)));
4210                 while (nparam < m->nparam_min + m->ndefs) {
4211                     params[nparam] = m->defaults[nparam - m->nparam_min];
4212                     nparam++;
4213                 }
4214             }
4215             /*
4216              * If we've gone over the maximum parameter count (and
4217              * we're in Plus mode), ignore parameters beyond
4218              * nparam_max.
4219              */
4220             if (m->plus && nparam > m->nparam_max)
4221                 nparam = m->nparam_max;
4222             /*
4223              * Then terminate the parameter list, and leave.
4224              */
4225             if (!params) {      /* need this special case */
4226                 params = nasm_malloc(sizeof(*params));
4227                 nparam = 0;
4228             }
4229             params[nparam] = NULL;
4230             *params_array = params;
4231             return m;
4232         }
4233         /*
4234          * This one wasn't right: look for the next one with the
4235          * same name.
4236          */
4237         for (m = m->next; m; m = m->next)
4238             if (!mstrcmp(m->name, tline->text, m->casesense))
4239                 break;
4240     }
4241
4242     /*
4243      * After all that, we didn't find one with the right number of
4244      * parameters. Issue a warning, and fail to expand the macro.
4245      */
4246     error(ERR_WARNING|ERR_PASS1|ERR_WARN_MNP,
4247           "macro `%s' exists, but not taking %d parameters",
4248           tline->text, nparam);
4249     nasm_free(params);
4250     return NULL;
4251 }
4252
4253
4254 /*
4255  * Save MMacro invocation specific fields in
4256  * preparation for a recursive macro expansion
4257  */
4258 static void push_mmacro(MMacro *m)
4259 {
4260     MMacroInvocation *i;
4261
4262     i = nasm_malloc(sizeof(MMacroInvocation));
4263     i->prev = m->prev;
4264     i->params = m->params;
4265     i->iline = m->iline;
4266     i->nparam = m->nparam;
4267     i->rotate = m->rotate;
4268     i->paramlen = m->paramlen;
4269     i->unique = m->unique;
4270     i->condcnt = m->condcnt;
4271     m->prev = i;
4272 }
4273
4274
4275 /*
4276  * Restore MMacro invocation specific fields that were
4277  * saved during a previous recursive macro expansion
4278  */
4279 static void pop_mmacro(MMacro *m)
4280 {
4281     MMacroInvocation *i;
4282
4283     if (m->prev) {
4284         i = m->prev;
4285         m->prev = i->prev;
4286         m->params = i->params;
4287         m->iline = i->iline;
4288         m->nparam = i->nparam;
4289         m->rotate = i->rotate;
4290         m->paramlen = i->paramlen;
4291         m->unique = i->unique;
4292         m->condcnt = i->condcnt;
4293         nasm_free(i);
4294     }
4295 }
4296
4297
4298 /*
4299  * Expand the multi-line macro call made by the given line, if
4300  * there is one to be expanded. If there is, push the expansion on
4301  * istk->expansion and return 1. Otherwise return 0.
4302  */
4303 static int expand_mmacro(Token * tline)
4304 {
4305     Token *startline = tline;
4306     Token *label = NULL;
4307     int dont_prepend = 0;
4308     Token **params, *t, *mtok, *tt;
4309     MMacro *m;
4310     Line *l, *ll;
4311     int i, nparam, *paramlen;
4312     const char *mname;
4313
4314     t = tline;
4315     skip_white_(t);
4316     /*    if (!tok_type_(t, TOK_ID))  Lino 02/25/02 */
4317     if (!tok_type_(t, TOK_ID) && !tok_type_(t, TOK_PREPROC_ID))
4318         return 0;
4319     mtok = t;
4320     m = is_mmacro(t, &params);
4321     if (m) {
4322         mname = t->text;
4323     } else {
4324         Token *last;
4325         /*
4326          * We have an id which isn't a macro call. We'll assume
4327          * it might be a label; we'll also check to see if a
4328          * colon follows it. Then, if there's another id after
4329          * that lot, we'll check it again for macro-hood.
4330          */
4331         label = last = t;
4332         t = t->next;
4333         if (tok_type_(t, TOK_WHITESPACE))
4334             last = t, t = t->next;
4335         if (tok_is_(t, ":")) {
4336             dont_prepend = 1;
4337             last = t, t = t->next;
4338             if (tok_type_(t, TOK_WHITESPACE))
4339                 last = t, t = t->next;
4340         }
4341         if (!tok_type_(t, TOK_ID) || !(m = is_mmacro(t, &params)))
4342             return 0;
4343         last->next = NULL;
4344         mname = t->text;
4345         tline = t;
4346     }
4347
4348     /*
4349      * Fix up the parameters: this involves stripping leading and
4350      * trailing whitespace, then stripping braces if they are
4351      * present.
4352      */
4353     for (nparam = 0; params[nparam]; nparam++) ;
4354     paramlen = nparam ? nasm_malloc(nparam * sizeof(*paramlen)) : NULL;
4355
4356     for (i = 0; params[i]; i++) {
4357         int brace = false;
4358         int comma = (!m->plus || i < nparam - 1);
4359
4360         t = params[i];
4361         skip_white_(t);
4362         if (tok_is_(t, "{"))
4363             t = t->next, brace = true, comma = false;
4364         params[i] = t;
4365         paramlen[i] = 0;
4366         while (t) {
4367             if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
4368                 break;          /* ... because we have hit a comma */
4369             if (comma && t->type == TOK_WHITESPACE
4370                 && tok_is_(t->next, ","))
4371                 break;          /* ... or a space then a comma */
4372             if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
4373                 break;          /* ... or a brace */
4374             t = t->next;
4375             paramlen[i]++;
4376         }
4377     }
4378
4379     /*
4380      * OK, we have a MMacro structure together with a set of
4381      * parameters. We must now go through the expansion and push
4382      * copies of each Line on to istk->expansion. Substitution of
4383      * parameter tokens and macro-local tokens doesn't get done
4384      * until the single-line macro substitution process; this is
4385      * because delaying them allows us to change the semantics
4386      * later through %rotate.
4387      *
4388      * First, push an end marker on to istk->expansion, mark this
4389      * macro as in progress, and set up its invocation-specific
4390      * variables.
4391      */
4392     ll = nasm_malloc(sizeof(Line));
4393     ll->next = istk->expansion;
4394     ll->finishes = m;
4395     ll->first = NULL;
4396     istk->expansion = ll;
4397
4398     /*
4399      * Save the previous MMacro expansion in the case of
4400      * macro recursion
4401      */
4402     if (m->max_depth && m->in_progress)
4403         push_mmacro(m);
4404
4405     m->in_progress ++;
4406     m->params = params;
4407     m->iline = tline;
4408     m->nparam = nparam;
4409     m->rotate = 0;
4410     m->paramlen = paramlen;
4411     m->unique = unique++;
4412     m->lineno = 0;
4413     m->condcnt = 0;
4414
4415     m->next_active = istk->mstk;
4416     istk->mstk = m;
4417
4418     for (l = m->expansion; l; l = l->next) {
4419         Token **tail;
4420
4421         ll = nasm_malloc(sizeof(Line));
4422         ll->finishes = NULL;
4423         ll->next = istk->expansion;
4424         istk->expansion = ll;
4425         tail = &ll->first;
4426
4427         for (t = l->first; t; t = t->next) {
4428             Token *x = t;
4429             switch (t->type) {
4430             case TOK_PREPROC_Q:
4431                 tt = *tail = new_Token(NULL, TOK_ID, mname, 0);
4432                 break;
4433             case TOK_PREPROC_QQ:
4434                 tt = *tail = new_Token(NULL, TOK_ID, m->name, 0);
4435                 break;
4436             case TOK_PREPROC_ID:
4437                 if (t->text[1] == '0' && t->text[2] == '0') {
4438                     dont_prepend = -1;
4439                     x = label;
4440                     if (!x)
4441                         continue;
4442                 }
4443                 /* fall through */
4444             default:
4445                 tt = *tail = new_Token(NULL, x->type, x->text, 0);
4446                 break;
4447             }
4448             tail = &tt->next;
4449         }
4450         *tail = NULL;
4451     }
4452
4453     /*
4454      * If we had a label, push it on as the first line of
4455      * the macro expansion.
4456      */
4457     if (label) {
4458         if (dont_prepend < 0)
4459             free_tlist(startline);
4460         else {
4461             ll = nasm_malloc(sizeof(Line));
4462             ll->finishes = NULL;
4463             ll->next = istk->expansion;
4464             istk->expansion = ll;
4465             ll->first = startline;
4466             if (!dont_prepend) {
4467                 while (label->next)
4468                     label = label->next;
4469                 label->next = tt = new_Token(NULL, TOK_OTHER, ":", 0);
4470             }
4471         }
4472     }
4473
4474     list->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
4475
4476     return 1;
4477 }
4478
4479 /* The function that actually does the error reporting */
4480 static void verror(int severity, const char *fmt, va_list arg)
4481 {
4482     char buff[1024];
4483
4484     vsnprintf(buff, sizeof(buff), fmt, arg);
4485
4486     if (istk && istk->mstk && istk->mstk->name)
4487         nasm_error(severity, "(%s:%d) %s", istk->mstk->name,
4488                istk->mstk->lineno, buff);
4489     else
4490         nasm_error(severity, "%s", buff);
4491 }
4492
4493 /*
4494  * Since preprocessor always operate only on the line that didn't
4495  * arrived yet, we should always use ERR_OFFBY1.
4496  */
4497 static void error(int severity, const char *fmt, ...)
4498 {
4499     va_list arg;
4500
4501     /* If we're in a dead branch of IF or something like it, ignore the error */
4502     if (istk && istk->conds && !emitting(istk->conds->state))
4503         return;
4504
4505     va_start(arg, fmt);
4506     verror(severity, fmt, arg);
4507     va_end(arg);
4508 }
4509
4510 /*
4511  * Because %else etc are evaluated in the state context
4512  * of the previous branch, errors might get lost with error():
4513  *   %if 0 ... %else trailing garbage ... %endif
4514  * So %else etc should report errors with this function.
4515  */
4516 static void error_precond(int severity, const char *fmt, ...)
4517 {
4518     va_list arg;
4519
4520     /* Only ignore the error if it's really in a dead branch */
4521     if (istk && istk->conds && istk->conds->state == COND_NEVER)
4522         return;
4523
4524     va_start(arg, fmt);
4525     verror(severity, fmt, arg);
4526     va_end(arg);
4527 }
4528
4529 static void
4530 pp_reset(char *file, int apass, ListGen * listgen, StrList **deplist)
4531 {
4532     Token *t;
4533
4534     cstk = NULL;
4535     istk = nasm_malloc(sizeof(Include));
4536     istk->next = NULL;
4537     istk->conds = NULL;
4538     istk->expansion = NULL;
4539     istk->mstk = NULL;
4540     istk->fp = fopen(file, "r");
4541     istk->fname = NULL;
4542     src_set_fname(nasm_strdup(file));
4543     src_set_linnum(0);
4544     istk->lineinc = 1;
4545     if (!istk->fp)
4546         error(ERR_FATAL|ERR_NOFILE, "unable to open input file `%s'",
4547               file);
4548     defining = NULL;
4549     nested_mac_count = 0;
4550     nested_rep_count = 0;
4551     init_macros();
4552     unique = 0;
4553     if (tasm_compatible_mode) {
4554         stdmacpos = nasm_stdmac;
4555     } else {
4556         stdmacpos = nasm_stdmac_after_tasm;
4557     }
4558     any_extrastdmac = extrastdmac && *extrastdmac;
4559     do_predef = true;
4560     list = listgen;
4561
4562     /*
4563      * 0 for dependencies, 1 for preparatory passes, 2 for final pass.
4564      * The caller, however, will also pass in 3 for preprocess-only so
4565      * we can set __PASS__ accordingly.
4566      */
4567     pass = apass > 2 ? 2 : apass;
4568
4569     dephead = deptail = deplist;
4570     if (deplist) {
4571         StrList *sl = nasm_malloc(strlen(file)+1+sizeof sl->next);
4572         sl->next = NULL;
4573         strcpy(sl->str, file);
4574         *deptail = sl;
4575         deptail = &sl->next;
4576     }
4577
4578     /*
4579      * Define the __PASS__ macro.  This is defined here unlike
4580      * all the other builtins, because it is special -- it varies between
4581      * passes.
4582      */
4583     t = nasm_malloc(sizeof(*t));
4584     t->next = NULL;
4585     make_tok_num(t, apass);
4586     t->a.mac = NULL;
4587     define_smacro(NULL, "__PASS__", true, 0, t);
4588 }
4589
4590 static char *pp_getline(void)
4591 {
4592     char *line;
4593     Token *tline;
4594
4595     while (1) {
4596         /*
4597          * Fetch a tokenized line, either from the macro-expansion
4598          * buffer or from the input file.
4599          */
4600         tline = NULL;
4601         while (istk->expansion && istk->expansion->finishes) {
4602             Line *l = istk->expansion;
4603             if (!l->finishes->name && l->finishes->in_progress > 1) {
4604                 Line *ll;
4605
4606                 /*
4607                  * This is a macro-end marker for a macro with no
4608                  * name, which means it's not really a macro at all
4609                  * but a %rep block, and the `in_progress' field is
4610                  * more than 1, meaning that we still need to
4611                  * repeat. (1 means the natural last repetition; 0
4612                  * means termination by %exitrep.) We have
4613                  * therefore expanded up to the %endrep, and must
4614                  * push the whole block on to the expansion buffer
4615                  * again. We don't bother to remove the macro-end
4616                  * marker: we'd only have to generate another one
4617                  * if we did.
4618                  */
4619                 l->finishes->in_progress--;
4620                 for (l = l->finishes->expansion; l; l = l->next) {
4621                     Token *t, *tt, **tail;
4622
4623                     ll = nasm_malloc(sizeof(Line));
4624                     ll->next = istk->expansion;
4625                     ll->finishes = NULL;
4626                     ll->first = NULL;
4627                     tail = &ll->first;
4628
4629                     for (t = l->first; t; t = t->next) {
4630                         if (t->text || t->type == TOK_WHITESPACE) {
4631                             tt = *tail =
4632                                 new_Token(NULL, t->type, t->text, 0);
4633                             tail = &tt->next;
4634                         }
4635                     }
4636
4637                     istk->expansion = ll;
4638                 }
4639             } else {
4640                 /*
4641                  * Check whether a `%rep' was started and not ended
4642                  * within this macro expansion. This can happen and
4643                  * should be detected. It's a fatal error because
4644                  * I'm too confused to work out how to recover
4645                  * sensibly from it.
4646                  */
4647                 if (defining) {
4648                     if (defining->name)
4649                         error(ERR_PANIC,
4650                               "defining with name in expansion");
4651                     else if (istk->mstk->name)
4652                         error(ERR_FATAL,
4653                               "`%%rep' without `%%endrep' within"
4654                               " expansion of macro `%s'",
4655                               istk->mstk->name);
4656                 }
4657
4658                 /*
4659                  * FIXME:  investigate the relationship at this point between
4660                  * istk->mstk and l->finishes
4661                  */
4662                 {
4663                     MMacro *m = istk->mstk;
4664                     istk->mstk = m->next_active;
4665                     if (m->name) {
4666                         /*
4667                          * This was a real macro call, not a %rep, and
4668                          * therefore the parameter information needs to
4669                          * be freed.
4670                          */
4671                         if (m->prev) {
4672                             pop_mmacro(m);
4673                             l->finishes->in_progress --;
4674                         } else {
4675                             nasm_free(m->params);
4676                             free_tlist(m->iline);
4677                             nasm_free(m->paramlen);
4678                             l->finishes->in_progress = 0;
4679                         }
4680                     } else
4681                         free_mmacro(m);
4682                 }
4683                 istk->expansion = l->next;
4684                 nasm_free(l);
4685                 list->downlevel(LIST_MACRO);
4686             }
4687         }
4688         while (1) {             /* until we get a line we can use */
4689
4690             if (istk->expansion) {      /* from a macro expansion */
4691                 char *p;
4692                 Line *l = istk->expansion;
4693                 if (istk->mstk)
4694                     istk->mstk->lineno++;
4695                 tline = l->first;
4696                 istk->expansion = l->next;
4697                 nasm_free(l);
4698                 p = detoken(tline, false);
4699                 list->line(LIST_MACRO, p);
4700                 nasm_free(p);
4701                 break;
4702             }
4703             line = read_line();
4704             if (line) {         /* from the current input file */
4705                 line = prepreproc(line);
4706                 tline = tokenize(line);
4707                 nasm_free(line);
4708                 break;
4709             }
4710             /*
4711              * The current file has ended; work down the istk
4712              */
4713             {
4714                 Include *i = istk;
4715                 fclose(i->fp);
4716                 if (i->conds)
4717                     error(ERR_FATAL,
4718                           "expected `%%endif' before end of file");
4719                 /* only set line and file name if there's a next node */
4720                 if (i->next) {
4721                     src_set_linnum(i->lineno);
4722                     nasm_free(src_set_fname(i->fname));
4723                 }
4724                 istk = i->next;
4725                 list->downlevel(LIST_INCLUDE);
4726                 nasm_free(i);
4727                 if (!istk)
4728                     return NULL;
4729                 if (istk->expansion && istk->expansion->finishes)
4730                     break;
4731             }
4732         }
4733
4734         /*
4735          * We must expand MMacro parameters and MMacro-local labels
4736          * _before_ we plunge into directive processing, to cope
4737          * with things like `%define something %1' such as STRUC
4738          * uses. Unless we're _defining_ a MMacro, in which case
4739          * those tokens should be left alone to go into the
4740          * definition; and unless we're in a non-emitting
4741          * condition, in which case we don't want to meddle with
4742          * anything.
4743          */
4744         if (!defining && !(istk->conds && !emitting(istk->conds->state))
4745             && !(istk->mstk && !istk->mstk->in_progress)) {
4746             tline = expand_mmac_params(tline);
4747         }
4748
4749         /*
4750          * Check the line to see if it's a preprocessor directive.
4751          */
4752         if (do_directive(tline) == DIRECTIVE_FOUND) {
4753             continue;
4754         } else if (defining) {
4755             /*
4756              * We're defining a multi-line macro. We emit nothing
4757              * at all, and just
4758              * shove the tokenized line on to the macro definition.
4759              */
4760             Line *l = nasm_malloc(sizeof(Line));
4761             l->next = defining->expansion;
4762             l->first = tline;
4763             l->finishes = NULL;
4764             defining->expansion = l;
4765             continue;
4766         } else if (istk->conds && !emitting(istk->conds->state)) {
4767             /*
4768              * We're in a non-emitting branch of a condition block.
4769              * Emit nothing at all, not even a blank line: when we
4770              * emerge from the condition we'll give a line-number
4771              * directive so we keep our place correctly.
4772              */
4773             free_tlist(tline);
4774             continue;
4775         } else if (istk->mstk && !istk->mstk->in_progress) {
4776             /*
4777              * We're in a %rep block which has been terminated, so
4778              * we're walking through to the %endrep without
4779              * emitting anything. Emit nothing at all, not even a
4780              * blank line: when we emerge from the %rep block we'll
4781              * give a line-number directive so we keep our place
4782              * correctly.
4783              */
4784             free_tlist(tline);
4785             continue;
4786         } else {
4787             tline = expand_smacro(tline);
4788             if (!expand_mmacro(tline)) {
4789                 /*
4790                  * De-tokenize the line again, and emit it.
4791                  */
4792                 line = detoken(tline, true);
4793                 free_tlist(tline);
4794                 break;
4795             } else {
4796                 continue;       /* expand_mmacro calls free_tlist */
4797             }
4798         }
4799     }
4800
4801     return line;
4802 }
4803
4804 static void pp_cleanup(int pass)
4805 {
4806     if (defining) {
4807         if (defining->name) {
4808             error(ERR_NONFATAL,
4809                   "end of file while still defining macro `%s'",
4810                   defining->name);
4811         } else {
4812             error(ERR_NONFATAL, "end of file while still in %%rep");
4813         }
4814
4815         free_mmacro(defining);
4816         defining = NULL;
4817     }
4818     while (cstk)
4819         ctx_pop();
4820     free_macros();
4821     while (istk) {
4822         Include *i = istk;
4823         istk = istk->next;
4824         fclose(i->fp);
4825         nasm_free(i->fname);
4826         nasm_free(i);
4827     }
4828     while (cstk)
4829         ctx_pop();
4830     nasm_free(src_set_fname(NULL));
4831     if (pass == 0) {
4832         IncPath *i;
4833         free_llist(predef);
4834         delete_Blocks();
4835         while ((i = ipath)) {
4836             ipath = i->next;
4837             if (i->path)
4838                 nasm_free(i->path);
4839             nasm_free(i);
4840         }
4841     }
4842 }
4843
4844 void pp_include_path(char *path)
4845 {
4846     IncPath *i;
4847
4848     i = nasm_malloc(sizeof(IncPath));
4849     i->path = path ? nasm_strdup(path) : NULL;
4850     i->next = NULL;
4851
4852     if (ipath) {
4853         IncPath *j = ipath;
4854         while (j->next)
4855             j = j->next;
4856         j->next = i;
4857     } else {
4858         ipath = i;
4859     }
4860 }
4861
4862 void pp_pre_include(char *fname)
4863 {
4864     Token *inc, *space, *name;
4865     Line *l;
4866
4867     name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
4868     space = new_Token(name, TOK_WHITESPACE, NULL, 0);
4869     inc = new_Token(space, TOK_PREPROC_ID, "%include", 0);
4870
4871     l = nasm_malloc(sizeof(Line));
4872     l->next = predef;
4873     l->first = inc;
4874     l->finishes = NULL;
4875     predef = l;
4876 }
4877
4878 void pp_pre_define(char *definition)
4879 {
4880     Token *def, *space;
4881     Line *l;
4882     char *equals;
4883
4884     equals = strchr(definition, '=');
4885     space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4886     def = new_Token(space, TOK_PREPROC_ID, "%define", 0);
4887     if (equals)
4888         *equals = ' ';
4889     space->next = tokenize(definition);
4890     if (equals)
4891         *equals = '=';
4892
4893     l = nasm_malloc(sizeof(Line));
4894     l->next = predef;
4895     l->first = def;
4896     l->finishes = NULL;
4897     predef = l;
4898 }
4899
4900 void pp_pre_undefine(char *definition)
4901 {
4902     Token *def, *space;
4903     Line *l;
4904
4905     space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4906     def = new_Token(space, TOK_PREPROC_ID, "%undef", 0);
4907     space->next = tokenize(definition);
4908
4909     l = nasm_malloc(sizeof(Line));
4910     l->next = predef;
4911     l->first = def;
4912     l->finishes = NULL;
4913     predef = l;
4914 }
4915
4916 /*
4917  * Added by Keith Kanios:
4918  *
4919  * This function is used to assist with "runtime" preprocessor
4920  * directives. (e.g. pp_runtime("%define __BITS__ 64");)
4921  *
4922  * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
4923  * PASS A VALID STRING TO THIS FUNCTION!!!!!
4924  */
4925
4926 void pp_runtime(char *definition)
4927 {
4928     Token *def;
4929
4930     def = tokenize(definition);
4931     if (do_directive(def) == NO_DIRECTIVE_FOUND)
4932         free_tlist(def);
4933
4934 }
4935
4936 void pp_extra_stdmac(macros_t *macros)
4937 {
4938     extrastdmac = macros;
4939 }
4940
4941 static void make_tok_num(Token * tok, int64_t val)
4942 {
4943     char numbuf[20];
4944     snprintf(numbuf, sizeof(numbuf), "%"PRId64"", val);
4945     tok->text = nasm_strdup(numbuf);
4946     tok->type = TOK_NUMBER;
4947 }
4948
4949 Preproc nasmpp = {
4950     pp_reset,
4951     pp_getline,
4952     pp_cleanup
4953 };