preproc.c

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