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 license given in the file "LICENSE"
   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             j = j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2125         }
2126         cond = nasm_malloc(sizeof(Cond));
2127         cond->next = istk->conds;
2128         cond->state = j;
2129         istk->conds = cond;
2130         free_tlist(origline);
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             istk->conds->state =
2151                 j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2152         }
2153         free_tlist(origline);
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 #define DEADMAN_LIMIT (1 << 20)
2985
2986 static Token *expand_smacro(Token * tline)
2987 {
2988     Token *t, *tt, *mstart, **tail, *thead;
2989     SMacro *head = NULL, *m;
2990     Token **params;
2991     int *paramsize;
2992     unsigned int nparam, sparam;
2993     int brackets, rescan;
2994     Token *org_tline = tline;
2995     Context *ctx;
2996     char *mname;
2997     int deadman = DEADMAN_LIMIT;
2998
2999     /*
3000      * Trick: we should avoid changing the start token pointer since it can
3001      * be contained in "next" field of other token. Because of this
3002      * we allocate a copy of first token and work with it; at the end of
3003      * routine we copy it back
3004      */
3005     if (org_tline) {
3006         tline =
3007             new_Token(org_tline->next, org_tline->type, org_tline->text,
3008                       0);
3009         tline->mac = org_tline->mac;
3010         nasm_free(org_tline->text);
3011         org_tline->text = NULL;
3012     }
3013
3014 again:
3015     tail = &thead;
3016     thead = NULL;
3017
3018     while (tline) {             /* main token loop */
3019         if (!--deadman) {
3020             error(ERR_NONFATAL, "interminable macro recursion");
3021             break;
3022         }
3023
3024         if ((mname = tline->text)) {
3025             /* if this token is a local macro, look in local context */
3026             if (tline->type == TOK_ID || tline->type == TOK_PREPROC_ID)
3027                 ctx = get_ctx(mname, true);
3028             else
3029                 ctx = NULL;
3030             if (!ctx) {
3031                 head = (SMacro *) hash_findix(smacros, mname);
3032             } else {
3033                 head = ctx->localmac;
3034             }
3035             /*
3036              * We've hit an identifier. As in is_mmacro below, we first
3037              * check whether the identifier is a single-line macro at
3038              * all, then think about checking for parameters if
3039              * necessary.
3040              */
3041             for (m = head; m; m = m->next)
3042                 if (!mstrcmp(m->name, mname, m->casesense))
3043                     break;
3044             if (m) {
3045                 mstart = tline;
3046                 params = NULL;
3047                 paramsize = NULL;
3048                 if (m->nparam == 0) {
3049                     /*
3050                      * Simple case: the macro is parameterless. Discard the
3051                      * one token that the macro call took, and push the
3052                      * expansion back on the to-do stack.
3053                      */
3054                     if (!m->expansion) {
3055                         if (!strcmp("__FILE__", m->name)) {
3056                             int32_t num = 0;
3057                             src_get(&num, &(tline->text));
3058                             nasm_quote(&(tline->text));
3059                             tline->type = TOK_STRING;
3060                             continue;
3061                         }
3062                         if (!strcmp("__LINE__", m->name)) {
3063                             nasm_free(tline->text);
3064                             make_tok_num(tline, src_get_linnum());
3065                             continue;
3066                         }
3067                         if (!strcmp("__BITS__", m->name)) {
3068                             nasm_free(tline->text);
3069                             make_tok_num(tline, globalbits);
3070                             continue;
3071                         }
3072                         tline = delete_Token(tline);
3073                         continue;
3074                     }
3075                 } else {
3076                     /*
3077                      * Complicated case: at least one macro with this name
3078                      * exists and takes parameters. We must find the
3079                      * parameters in the call, count them, find the SMacro
3080                      * that corresponds to that form of the macro call, and
3081                      * substitute for the parameters when we expand. What a
3082                      * pain.
3083                      */
3084                     /*tline = tline->next;
3085                        skip_white_(tline); */
3086                     do {
3087                         t = tline->next;
3088                         while (tok_type_(t, TOK_SMAC_END)) {
3089                             t->mac->in_progress = false;
3090                             t->text = NULL;
3091                             t = tline->next = delete_Token(t);
3092                         }
3093                         tline = t;
3094                     } while (tok_type_(tline, TOK_WHITESPACE));
3095                     if (!tok_is_(tline, "(")) {
3096                         /*
3097                          * This macro wasn't called with parameters: ignore
3098                          * the call. (Behaviour borrowed from gnu cpp.)
3099                          */
3100                         tline = mstart;
3101                         m = NULL;
3102                     } else {
3103                         int paren = 0;
3104                         int white = 0;
3105                         brackets = 0;
3106                         nparam = 0;
3107                         sparam = PARAM_DELTA;
3108                         params = nasm_malloc(sparam * sizeof(Token *));
3109                         params[0] = tline->next;
3110                         paramsize = nasm_malloc(sparam * sizeof(int));
3111                         paramsize[0] = 0;
3112                         while (true) {  /* parameter loop */
3113                             /*
3114                              * For some unusual expansions
3115                              * which concatenates function call
3116                              */
3117                             t = tline->next;
3118                             while (tok_type_(t, TOK_SMAC_END)) {
3119                                 t->mac->in_progress = false;
3120                                 t->text = NULL;
3121                                 t = tline->next = delete_Token(t);
3122                             }
3123                             tline = t;
3124
3125                             if (!tline) {
3126                                 error(ERR_NONFATAL,
3127                                       "macro call expects terminating `)'");
3128                                 break;
3129                             }
3130                             if (tline->type == TOK_WHITESPACE
3131                                 && brackets <= 0) {
3132                                 if (paramsize[nparam])
3133                                     white++;
3134                                 else
3135                                     params[nparam] = tline->next;
3136                                 continue;       /* parameter loop */
3137                             }
3138                             if (tline->type == TOK_OTHER
3139                                 && tline->text[1] == 0) {
3140                                 char ch = tline->text[0];
3141                                 if (ch == ',' && !paren && brackets <= 0) {
3142                                     if (++nparam >= sparam) {
3143                                         sparam += PARAM_DELTA;
3144                                         params = nasm_realloc(params,
3145                                                               sparam *
3146                                                               sizeof(Token
3147                                                                      *));
3148                                         paramsize =
3149                                             nasm_realloc(paramsize,
3150                                                          sparam *
3151                                                          sizeof(int));
3152                                     }
3153                                     params[nparam] = tline->next;
3154                                     paramsize[nparam] = 0;
3155                                     white = 0;
3156                                     continue;   /* parameter loop */
3157                                 }
3158                                 if (ch == '{' &&
3159                                     (brackets > 0 || (brackets == 0 &&
3160                                                       !paramsize[nparam])))
3161                                 {
3162                                     if (!(brackets++)) {
3163                                         params[nparam] = tline->next;
3164                                         continue;       /* parameter loop */
3165                                     }
3166                                 }
3167                                 if (ch == '}' && brackets > 0)
3168                                     if (--brackets == 0) {
3169                                         brackets = -1;
3170                                         continue;       /* parameter loop */
3171                                     }
3172                                 if (ch == '(' && !brackets)
3173                                     paren++;
3174                                 if (ch == ')' && brackets <= 0)
3175                                     if (--paren < 0)
3176                                         break;
3177                             }
3178                             if (brackets < 0) {
3179                                 brackets = 0;
3180                                 error(ERR_NONFATAL, "braces do not "
3181                                       "enclose all of macro parameter");
3182                             }
3183                             paramsize[nparam] += white + 1;
3184                             white = 0;
3185                         }       /* parameter loop */
3186                         nparam++;
3187                         while (m && (m->nparam != nparam ||
3188                                      mstrcmp(m->name, mname,
3189                                              m->casesense)))
3190                             m = m->next;
3191                         if (!m)
3192                             error(ERR_WARNING | ERR_WARN_MNP,
3193                                   "macro `%s' exists, "
3194                                   "but not taking %d parameters",
3195                                   mstart->text, nparam);
3196                     }
3197                 }
3198                 if (m && m->in_progress)
3199                     m = NULL;
3200                 if (!m) {       /* in progess or didn't find '(' or wrong nparam */
3201                     /*
3202                      * Design question: should we handle !tline, which
3203                      * indicates missing ')' here, or expand those
3204                      * macros anyway, which requires the (t) test a few
3205                      * lines down?
3206                      */
3207                     nasm_free(params);
3208                     nasm_free(paramsize);
3209                     tline = mstart;
3210                 } else {
3211                     /*
3212                      * Expand the macro: we are placed on the last token of the
3213                      * call, so that we can easily split the call from the
3214                      * following tokens. We also start by pushing an SMAC_END
3215                      * token for the cycle removal.
3216                      */
3217                     t = tline;
3218                     if (t) {
3219                         tline = t->next;
3220                         t->next = NULL;
3221                     }
3222                     tt = new_Token(tline, TOK_SMAC_END, NULL, 0);
3223                     tt->mac = m;
3224                     m->in_progress = true;
3225                     tline = tt;
3226                     for (t = m->expansion; t; t = t->next) {
3227                         if (t->type >= TOK_SMAC_PARAM) {
3228                             Token *pcopy = tline, **ptail = &pcopy;
3229                             Token *ttt, *pt;
3230                             int i;
3231
3232                             ttt = params[t->type - TOK_SMAC_PARAM];
3233                             for (i = paramsize[t->type - TOK_SMAC_PARAM];
3234                                  --i >= 0;) {
3235                                 pt = *ptail =
3236                                     new_Token(tline, ttt->type, ttt->text,
3237                                               0);
3238                                 ptail = &pt->next;
3239                                 ttt = ttt->next;
3240                             }
3241                             tline = pcopy;
3242                         } else {
3243                             tt = new_Token(tline, t->type, t->text, 0);
3244                             tline = tt;
3245                         }
3246                     }
3247
3248                     /*
3249                      * Having done that, get rid of the macro call, and clean
3250                      * up the parameters.
3251                      */
3252                     nasm_free(params);
3253                     nasm_free(paramsize);
3254                     free_tlist(mstart);
3255                     continue;   /* main token loop */
3256                 }
3257             }
3258         }
3259
3260         if (tline->type == TOK_SMAC_END) {
3261             tline->mac->in_progress = false;
3262             tline = delete_Token(tline);
3263         } else {
3264             t = *tail = tline;
3265             tline = tline->next;
3266             t->mac = NULL;
3267             t->next = NULL;
3268             tail = &t->next;
3269         }
3270     }
3271
3272     /*
3273      * Now scan the entire line and look for successive TOK_IDs that resulted
3274      * after expansion (they can't be produced by tokenize()). The successive
3275      * TOK_IDs should be concatenated.
3276      * Also we look for %+ tokens and concatenate the tokens before and after
3277      * them (without white spaces in between).
3278      */
3279     t = thead;
3280     rescan = 0;
3281     while (t) {
3282         while (t && t->type != TOK_ID && t->type != TOK_PREPROC_ID)
3283             t = t->next;
3284         if (!t || !t->next)
3285             break;
3286         if (t->next->type == TOK_ID ||
3287             t->next->type == TOK_PREPROC_ID ||
3288             t->next->type == TOK_NUMBER) {
3289             char *p = nasm_strcat(t->text, t->next->text);
3290             nasm_free(t->text);
3291             t->next = delete_Token(t->next);
3292             t->text = p;
3293             rescan = 1;
3294         } else if (t->next->type == TOK_WHITESPACE && t->next->next &&
3295                    t->next->next->type == TOK_PREPROC_ID &&
3296                    strcmp(t->next->next->text, "%+") == 0) {
3297             /* free the next whitespace, the %+ token and next whitespace */
3298             int i;
3299             for (i = 1; i <= 3; i++) {
3300                 if (!t->next
3301                     || (i != 2 && t->next->type != TOK_WHITESPACE))
3302                     break;
3303                 t->next = delete_Token(t->next);
3304             }                   /* endfor */
3305         } else
3306             t = t->next;
3307     }
3308     /* If we concatenaded something, re-scan the line for macros */
3309     if (rescan) {
3310         tline = thead;
3311         goto again;
3312     }
3313
3314     if (org_tline) {
3315         if (thead) {
3316             *org_tline = *thead;
3317             /* since we just gave text to org_line, don't free it */
3318             thead->text = NULL;
3319             delete_Token(thead);
3320         } else {
3321             /* the expression expanded to empty line;
3322                we can't return NULL for some reasons
3323                we just set the line to a single WHITESPACE token. */
3324             memset(org_tline, 0, sizeof(*org_tline));
3325             org_tline->text = NULL;
3326             org_tline->type = TOK_WHITESPACE;
3327         }
3328         thead = org_tline;
3329     }
3330
3331     return thead;
3332 }
3333
3334 /*
3335  * Similar to expand_smacro but used exclusively with macro identifiers
3336  * right before they are fetched in. The reason is that there can be
3337  * identifiers consisting of several subparts. We consider that if there
3338  * are more than one element forming the name, user wants a expansion,
3339  * otherwise it will be left as-is. Example:
3340  *
3341  *      %define %$abc cde
3342  *
3343  * the identifier %$abc will be left as-is so that the handler for %define
3344  * will suck it and define the corresponding value. Other case:
3345  *
3346  *      %define _%$abc cde
3347  *
3348  * In this case user wants name to be expanded *before* %define starts
3349  * working, so we'll expand %$abc into something (if it has a value;
3350  * otherwise it will be left as-is) then concatenate all successive
3351  * PP_IDs into one.
3352  */
3353 static Token *expand_id(Token * tline)
3354 {
3355     Token *cur, *oldnext = NULL;
3356
3357     if (!tline || !tline->next)
3358         return tline;
3359
3360     cur = tline;
3361     while (cur->next &&
3362            (cur->next->type == TOK_ID ||
3363             cur->next->type == TOK_PREPROC_ID
3364             || cur->next->type == TOK_NUMBER))
3365         cur = cur->next;
3366
3367     /* If identifier consists of just one token, don't expand */
3368     if (cur == tline)
3369         return tline;
3370
3371     if (cur) {
3372         oldnext = cur->next;    /* Detach the tail past identifier */
3373         cur->next = NULL;       /* so that expand_smacro stops here */
3374     }
3375
3376     tline = expand_smacro(tline);
3377
3378     if (cur) {
3379         /* expand_smacro possibly changhed tline; re-scan for EOL */
3380         cur = tline;
3381         while (cur && cur->next)
3382             cur = cur->next;
3383         if (cur)
3384             cur->next = oldnext;
3385     }
3386
3387     return tline;
3388 }
3389
3390 /*
3391  * Determine whether the given line constitutes a multi-line macro
3392  * call, and return the MMacro structure called if so. Doesn't have
3393  * to check for an initial label - that's taken care of in
3394  * expand_mmacro - but must check numbers of parameters. Guaranteed
3395  * to be called with tline->type == TOK_ID, so the putative macro
3396  * name is easy to find.
3397  */
3398 static MMacro *is_mmacro(Token * tline, Token *** params_array)
3399 {
3400     MMacro *head, *m;
3401     Token **params;
3402     int nparam;
3403
3404     head = (MMacro *) hash_findix(mmacros, tline->text);
3405
3406     /*
3407      * Efficiency: first we see if any macro exists with the given
3408      * name. If not, we can return NULL immediately. _Then_ we
3409      * count the parameters, and then we look further along the
3410      * list if necessary to find the proper MMacro.
3411      */
3412     for (m = head; m; m = m->next)
3413         if (!mstrcmp(m->name, tline->text, m->casesense))
3414             break;
3415     if (!m)
3416         return NULL;
3417
3418     /*
3419      * OK, we have a potential macro. Count and demarcate the
3420      * parameters.
3421      */
3422     count_mmac_params(tline->next, &nparam, &params);
3423
3424     /*
3425      * So we know how many parameters we've got. Find the MMacro
3426      * structure that handles this number.
3427      */
3428     while (m) {
3429         if (m->nparam_min <= nparam
3430             && (m->plus || nparam <= m->nparam_max)) {
3431             /*
3432              * This one is right. Just check if cycle removal
3433              * prohibits us using it before we actually celebrate...
3434              */
3435             if (m->in_progress) {
3436 #if 0
3437                 error(ERR_NONFATAL,
3438                       "self-reference in multi-line macro `%s'", m->name);
3439 #endif
3440                 nasm_free(params);
3441                 return NULL;
3442             }
3443             /*
3444              * It's right, and we can use it. Add its default
3445              * parameters to the end of our list if necessary.
3446              */
3447             if (m->defaults && nparam < m->nparam_min + m->ndefs) {
3448                 params =
3449                     nasm_realloc(params,
3450                                  ((m->nparam_min + m->ndefs +
3451                                    1) * sizeof(*params)));
3452                 while (nparam < m->nparam_min + m->ndefs) {
3453                     params[nparam] = m->defaults[nparam - m->nparam_min];
3454                     nparam++;
3455                 }
3456             }
3457             /*
3458              * If we've gone over the maximum parameter count (and
3459              * we're in Plus mode), ignore parameters beyond
3460              * nparam_max.
3461              */
3462             if (m->plus && nparam > m->nparam_max)
3463                 nparam = m->nparam_max;
3464             /*
3465              * Then terminate the parameter list, and leave.
3466              */
3467             if (!params) {      /* need this special case */
3468                 params = nasm_malloc(sizeof(*params));
3469                 nparam = 0;
3470             }
3471             params[nparam] = NULL;
3472             *params_array = params;
3473             return m;
3474         }
3475         /*
3476          * This one wasn't right: look for the next one with the
3477          * same name.
3478          */
3479         for (m = m->next; m; m = m->next)
3480             if (!mstrcmp(m->name, tline->text, m->casesense))
3481                 break;
3482     }
3483
3484     /*
3485      * After all that, we didn't find one with the right number of
3486      * parameters. Issue a warning, and fail to expand the macro.
3487      */
3488     error(ERR_WARNING | ERR_WARN_MNP,
3489           "macro `%s' exists, but not taking %d parameters",
3490           tline->text, nparam);
3491     nasm_free(params);
3492     return NULL;
3493 }
3494
3495 /*
3496  * Expand the multi-line macro call made by the given line, if
3497  * there is one to be expanded. If there is, push the expansion on
3498  * istk->expansion and return 1. Otherwise return 0.
3499  */
3500 static int expand_mmacro(Token * tline)
3501 {
3502     Token *startline = tline;
3503     Token *label = NULL;
3504     int dont_prepend = 0;
3505     Token **params, *t, *tt;
3506     MMacro *m;
3507     Line *l, *ll;
3508     int i, nparam, *paramlen;
3509
3510     t = tline;
3511     skip_white_(t);
3512 /*    if (!tok_type_(t, TOK_ID))  Lino 02/25/02 */
3513     if (!tok_type_(t, TOK_ID) && !tok_type_(t, TOK_PREPROC_ID))
3514         return 0;
3515     m = is_mmacro(t, &params);
3516     if (!m) {
3517         Token *last;
3518         /*
3519          * We have an id which isn't a macro call. We'll assume
3520          * it might be a label; we'll also check to see if a
3521          * colon follows it. Then, if there's another id after
3522          * that lot, we'll check it again for macro-hood.
3523          */
3524         label = last = t;
3525         t = t->next;
3526         if (tok_type_(t, TOK_WHITESPACE))
3527             last = t, t = t->next;
3528         if (tok_is_(t, ":")) {
3529             dont_prepend = 1;
3530             last = t, t = t->next;
3531             if (tok_type_(t, TOK_WHITESPACE))
3532                 last = t, t = t->next;
3533         }
3534         if (!tok_type_(t, TOK_ID) || (m = is_mmacro(t, &params)) == NULL)
3535             return 0;
3536         last->next = NULL;
3537         tline = t;
3538     }
3539
3540     /*
3541      * Fix up the parameters: this involves stripping leading and
3542      * trailing whitespace, then stripping braces if they are
3543      * present.
3544      */
3545     for (nparam = 0; params[nparam]; nparam++) ;
3546     paramlen = nparam ? nasm_malloc(nparam * sizeof(*paramlen)) : NULL;
3547
3548     for (i = 0; params[i]; i++) {
3549         int brace = false;
3550         int comma = (!m->plus || i < nparam - 1);
3551
3552         t = params[i];
3553         skip_white_(t);
3554         if (tok_is_(t, "{"))
3555             t = t->next, brace = true, comma = false;
3556         params[i] = t;
3557         paramlen[i] = 0;
3558         while (t) {
3559             if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
3560                 break;          /* ... because we have hit a comma */
3561             if (comma && t->type == TOK_WHITESPACE
3562                 && tok_is_(t->next, ","))
3563                 break;          /* ... or a space then a comma */
3564             if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
3565                 break;          /* ... or a brace */
3566             t = t->next;
3567             paramlen[i]++;
3568         }
3569     }
3570
3571     /*
3572      * OK, we have a MMacro structure together with a set of
3573      * parameters. We must now go through the expansion and push
3574      * copies of each Line on to istk->expansion. Substitution of
3575      * parameter tokens and macro-local tokens doesn't get done
3576      * until the single-line macro substitution process; this is
3577      * because delaying them allows us to change the semantics
3578      * later through %rotate.
3579      *
3580      * First, push an end marker on to istk->expansion, mark this
3581      * macro as in progress, and set up its invocation-specific
3582      * variables.
3583      */
3584     ll = nasm_malloc(sizeof(Line));
3585     ll->next = istk->expansion;
3586     ll->finishes = m;
3587     ll->first = NULL;
3588     istk->expansion = ll;
3589
3590     m->in_progress = true;
3591     m->params = params;
3592     m->iline = tline;
3593     m->nparam = nparam;
3594     m->rotate = 0;
3595     m->paramlen = paramlen;
3596     m->unique = unique++;
3597     m->lineno = 0;
3598
3599     m->next_active = istk->mstk;
3600     istk->mstk = m;
3601
3602     for (l = m->expansion; l; l = l->next) {
3603         Token **tail;
3604
3605         ll = nasm_malloc(sizeof(Line));
3606         ll->finishes = NULL;
3607         ll->next = istk->expansion;
3608         istk->expansion = ll;
3609         tail = &ll->first;
3610
3611         for (t = l->first; t; t = t->next) {
3612             Token *x = t;
3613             if (t->type == TOK_PREPROC_ID &&
3614                 t->text[1] == '0' && t->text[2] == '0') {
3615                 dont_prepend = -1;
3616                 x = label;
3617                 if (!x)
3618                     continue;
3619             }
3620             tt = *tail = new_Token(NULL, x->type, x->text, 0);
3621             tail = &tt->next;
3622         }
3623         *tail = NULL;
3624     }
3625
3626     /*
3627      * If we had a label, push it on as the first line of
3628      * the macro expansion.
3629      */
3630     if (label) {
3631         if (dont_prepend < 0)
3632             free_tlist(startline);
3633         else {
3634             ll = nasm_malloc(sizeof(Line));
3635             ll->finishes = NULL;
3636             ll->next = istk->expansion;
3637             istk->expansion = ll;
3638             ll->first = startline;
3639             if (!dont_prepend) {
3640                 while (label->next)
3641                     label = label->next;
3642                 label->next = tt = new_Token(NULL, TOK_OTHER, ":", 0);
3643             }
3644         }
3645     }
3646
3647     list->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
3648
3649     return 1;
3650 }
3651
3652 /*
3653  * Since preprocessor always operate only on the line that didn't
3654  * arrived yet, we should always use ERR_OFFBY1. Also since user
3655  * won't want to see same error twice (preprocessing is done once
3656  * per pass) we will want to show errors only during pass one.
3657  */
3658 static void error(int severity, const char *fmt, ...)
3659 {
3660     va_list arg;
3661     char buff[1024];
3662
3663     /* If we're in a dead branch of IF or something like it, ignore the error */
3664     if (istk && istk->conds && !emitting(istk->conds->state))
3665         return;
3666
3667     va_start(arg, fmt);
3668     vsnprintf(buff, sizeof(buff), fmt, arg);
3669     va_end(arg);
3670
3671     if (istk && istk->mstk && istk->mstk->name)
3672         _error(severity | ERR_PASS1, "(%s:%d) %s", istk->mstk->name,
3673                istk->mstk->lineno, buff);
3674     else
3675         _error(severity | ERR_PASS1, "%s", buff);
3676 }
3677
3678 static void
3679 pp_reset(char *file, int apass, efunc errfunc, evalfunc eval,
3680          ListGen * listgen)
3681 {
3682     _error = errfunc;
3683     cstk = NULL;
3684     istk = nasm_malloc(sizeof(Include));
3685     istk->next = NULL;
3686     istk->conds = NULL;
3687     istk->expansion = NULL;
3688     istk->mstk = NULL;
3689     istk->fp = fopen(file, "r");
3690     istk->fname = NULL;
3691     src_set_fname(nasm_strdup(file));
3692     src_set_linnum(0);
3693     istk->lineinc = 1;
3694     if (!istk->fp)
3695         error(ERR_FATAL | ERR_NOFILE, "unable to open input file `%s'",
3696               file);
3697     defining = NULL;
3698     init_macros();
3699     unique = 0;
3700     if (tasm_compatible_mode) {
3701         stdmacpos = stdmac;
3702     } else {
3703         stdmacpos = &stdmac[TASM_MACRO_COUNT];
3704     }
3705     any_extrastdmac = (extrastdmac != NULL);
3706     list = listgen;
3707     evaluate = eval;
3708     pass = apass;
3709 }
3710
3711 static char *pp_getline(void)
3712 {
3713     char *line;
3714     Token *tline;
3715
3716     while (1) {
3717         /*
3718          * Fetch a tokenized line, either from the macro-expansion
3719          * buffer or from the input file.
3720          */
3721         tline = NULL;
3722         while (istk->expansion && istk->expansion->finishes) {
3723             Line *l = istk->expansion;
3724             if (!l->finishes->name && l->finishes->in_progress > 1) {
3725                 Line *ll;
3726
3727                 /*
3728                  * This is a macro-end marker for a macro with no
3729                  * name, which means it's not really a macro at all
3730                  * but a %rep block, and the `in_progress' field is
3731                  * more than 1, meaning that we still need to
3732                  * repeat. (1 means the natural last repetition; 0
3733                  * means termination by %exitrep.) We have
3734                  * therefore expanded up to the %endrep, and must
3735                  * push the whole block on to the expansion buffer
3736                  * again. We don't bother to remove the macro-end
3737                  * marker: we'd only have to generate another one
3738                  * if we did.
3739                  */
3740                 l->finishes->in_progress--;
3741                 for (l = l->finishes->expansion; l; l = l->next) {
3742                     Token *t, *tt, **tail;
3743
3744                     ll = nasm_malloc(sizeof(Line));
3745                     ll->next = istk->expansion;
3746                     ll->finishes = NULL;
3747                     ll->first = NULL;
3748                     tail = &ll->first;
3749
3750                     for (t = l->first; t; t = t->next) {
3751                         if (t->text || t->type == TOK_WHITESPACE) {
3752                             tt = *tail =
3753                                 new_Token(NULL, t->type, t->text, 0);
3754                             tail = &tt->next;
3755                         }
3756                     }
3757
3758                     istk->expansion = ll;
3759                 }
3760             } else {
3761                 /*
3762                  * Check whether a `%rep' was started and not ended
3763                  * within this macro expansion. This can happen and
3764                  * should be detected. It's a fatal error because
3765                  * I'm too confused to work out how to recover
3766                  * sensibly from it.
3767                  */
3768                 if (defining) {
3769                     if (defining->name)
3770                         error(ERR_PANIC,
3771                               "defining with name in expansion");
3772                     else if (istk->mstk->name)
3773                         error(ERR_FATAL,
3774                               "`%%rep' without `%%endrep' within"
3775                               " expansion of macro `%s'",
3776                               istk->mstk->name);
3777                 }
3778
3779                 /*
3780                  * FIXME:  investigate the relationship at this point between
3781                  * istk->mstk and l->finishes
3782                  */
3783                 {
3784                     MMacro *m = istk->mstk;
3785                     istk->mstk = m->next_active;
3786                     if (m->name) {
3787                         /*
3788                          * This was a real macro call, not a %rep, and
3789                          * therefore the parameter information needs to
3790                          * be freed.
3791                          */
3792                         nasm_free(m->params);
3793                         free_tlist(m->iline);
3794                         nasm_free(m->paramlen);
3795                         l->finishes->in_progress = false;
3796                     } else
3797                         free_mmacro(m);
3798                 }
3799                 istk->expansion = l->next;
3800                 nasm_free(l);
3801                 list->downlevel(LIST_MACRO);
3802             }
3803         }
3804         while (1) {             /* until we get a line we can use */
3805
3806             if (istk->expansion) {      /* from a macro expansion */
3807                 char *p;
3808                 Line *l = istk->expansion;
3809                 if (istk->mstk)
3810                     istk->mstk->lineno++;
3811                 tline = l->first;
3812                 istk->expansion = l->next;
3813                 nasm_free(l);
3814                 p = detoken(tline, false);
3815                 list->line(LIST_MACRO, p);
3816                 nasm_free(p);
3817                 break;
3818             }
3819             line = read_line();
3820             if (line) {         /* from the current input file */
3821                 line = prepreproc(line);
3822                 tline = tokenize(line);
3823                 nasm_free(line);
3824                 break;
3825             }
3826             /*
3827              * The current file has ended; work down the istk
3828              */
3829             {
3830                 Include *i = istk;
3831                 fclose(i->fp);
3832                 if (i->conds)
3833                     error(ERR_FATAL,
3834                           "expected `%%endif' before end of file");
3835                 /* only set line and file name if there's a next node */
3836                 if (i->next) {
3837                     src_set_linnum(i->lineno);
3838                     nasm_free(src_set_fname(i->fname));
3839                 }
3840                 istk = i->next;
3841                 list->downlevel(LIST_INCLUDE);
3842                 nasm_free(i);
3843                 if (!istk)
3844                     return NULL;
3845             }
3846         }
3847
3848         /*
3849          * We must expand MMacro parameters and MMacro-local labels
3850          * _before_ we plunge into directive processing, to cope
3851          * with things like `%define something %1' such as STRUC
3852          * uses. Unless we're _defining_ a MMacro, in which case
3853          * those tokens should be left alone to go into the
3854          * definition; and unless we're in a non-emitting
3855          * condition, in which case we don't want to meddle with
3856          * anything.
3857          */
3858         if (!defining && !(istk->conds && !emitting(istk->conds->state)))
3859             tline = expand_mmac_params(tline);
3860
3861         /*
3862          * Check the line to see if it's a preprocessor directive.
3863          */
3864         if (do_directive(tline) == DIRECTIVE_FOUND) {
3865             continue;
3866         } else if (defining) {
3867             /*
3868              * We're defining a multi-line macro. We emit nothing
3869              * at all, and just
3870              * shove the tokenized line on to the macro definition.
3871              */
3872             Line *l = nasm_malloc(sizeof(Line));
3873             l->next = defining->expansion;
3874             l->first = tline;
3875             l->finishes = false;
3876             defining->expansion = l;
3877             continue;
3878         } else if (istk->conds && !emitting(istk->conds->state)) {
3879             /*
3880              * We're in a non-emitting branch of a condition block.
3881              * Emit nothing at all, not even a blank line: when we
3882              * emerge from the condition we'll give a line-number
3883              * directive so we keep our place correctly.
3884              */
3885             free_tlist(tline);
3886             continue;
3887         } else if (istk->mstk && !istk->mstk->in_progress) {
3888             /*
3889              * We're in a %rep block which has been terminated, so
3890              * we're walking through to the %endrep without
3891              * emitting anything. Emit nothing at all, not even a
3892              * blank line: when we emerge from the %rep block we'll
3893              * give a line-number directive so we keep our place
3894              * correctly.
3895              */
3896             free_tlist(tline);
3897             continue;
3898         } else {
3899             tline = expand_smacro(tline);
3900             if (!expand_mmacro(tline)) {
3901                 /*
3902                  * De-tokenize the line again, and emit it.
3903                  */
3904                 line = detoken(tline, true);
3905                 free_tlist(tline);
3906                 break;
3907             } else {
3908                 continue;       /* expand_mmacro calls free_tlist */
3909             }
3910         }
3911     }
3912
3913     return line;
3914 }
3915
3916 static void pp_cleanup(int pass)
3917 {
3918     if (defining) {
3919         error(ERR_NONFATAL, "end of file while still defining macro `%s'",
3920               defining->name);
3921         free_mmacro(defining);
3922     }
3923     while (cstk)
3924         ctx_pop();
3925     free_macros();
3926     while (istk) {
3927         Include *i = istk;
3928         istk = istk->next;
3929         fclose(i->fp);
3930         nasm_free(i->fname);
3931         nasm_free(i);
3932     }
3933     while (cstk)
3934         ctx_pop();
3935     if (pass == 0) {
3936         free_llist(predef);
3937         delete_Blocks();
3938     }
3939 }
3940
3941 void pp_include_path(char *path)
3942 {
3943     IncPath *i;
3944
3945     i = nasm_malloc(sizeof(IncPath));
3946     i->path = path ? nasm_strdup(path) : NULL;
3947     i->next = NULL;
3948
3949     if (ipath != NULL) {
3950         IncPath *j = ipath;
3951         while (j->next != NULL)
3952             j = j->next;
3953         j->next = i;
3954     } else {
3955         ipath = i;
3956     }
3957 }
3958
3959 /*
3960  * added by alexfru:
3961  *
3962  * This function is used to "export" the include paths, e.g.
3963  * the paths specified in the '-I' command switch.
3964  * The need for such exporting is due to the 'incbin' directive,
3965  * which includes raw binary files (unlike '%include', which
3966  * includes text source files). It would be real nice to be
3967  * able to specify paths to search for incbin'ned files also.
3968  * So, this is a simple workaround.
3969  *
3970  * The function use is simple:
3971  *
3972  * The 1st call (with NULL argument) returns a pointer to the 1st path
3973  * (char** type) or NULL if none include paths available.
3974  *
3975  * All subsequent calls take as argument the value returned by this
3976  * function last. The return value is either the next path
3977  * (char** type) or NULL if the end of the paths list is reached.
3978  *
3979  * It is maybe not the best way to do things, but I didn't want
3980  * to export too much, just one or two functions and no types or
3981  * variables exported.
3982  *
3983  * Can't say I like the current situation with e.g. this path list either,
3984  * it seems to be never deallocated after creation...
3985  */
3986 char **pp_get_include_path_ptr(char **pPrevPath)
3987 {
3988 /*   This macro returns offset of a member of a structure */
3989 #define GetMemberOffset(StructType,MemberName)\
3990   ((size_t)&((StructType*)0)->MemberName)
3991     IncPath *i;
3992
3993     if (pPrevPath == NULL) {
3994         if (ipath != NULL)
3995             return &ipath->path;
3996         else
3997             return NULL;
3998     }
3999     i = (IncPath *) ((char *)pPrevPath - GetMemberOffset(IncPath, path));
4000     i = i->next;
4001     if (i != NULL)
4002         return &i->path;
4003     else
4004         return NULL;
4005 #undef GetMemberOffset
4006 }
4007
4008 void pp_pre_include(char *fname)
4009 {
4010     Token *inc, *space, *name;
4011     Line *l;
4012
4013     name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
4014     space = new_Token(name, TOK_WHITESPACE, NULL, 0);
4015     inc = new_Token(space, TOK_PREPROC_ID, "%include", 0);
4016
4017     l = nasm_malloc(sizeof(Line));
4018     l->next = predef;
4019     l->first = inc;
4020     l->finishes = false;
4021     predef = l;
4022 }
4023
4024 void pp_pre_define(char *definition)
4025 {
4026     Token *def, *space;
4027     Line *l;
4028     char *equals;
4029
4030     equals = strchr(definition, '=');
4031     space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4032     def = new_Token(space, TOK_PREPROC_ID, "%define", 0);
4033     if (equals)
4034         *equals = ' ';
4035     space->next = tokenize(definition);
4036     if (equals)
4037         *equals = '=';
4038
4039     l = nasm_malloc(sizeof(Line));
4040     l->next = predef;
4041     l->first = def;
4042     l->finishes = false;
4043     predef = l;
4044 }
4045
4046 void pp_pre_undefine(char *definition)
4047 {
4048     Token *def, *space;
4049     Line *l;
4050
4051     space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4052     def = new_Token(space, TOK_PREPROC_ID, "%undef", 0);
4053     space->next = tokenize(definition);
4054
4055     l = nasm_malloc(sizeof(Line));
4056     l->next = predef;
4057     l->first = def;
4058     l->finishes = false;
4059     predef = l;
4060 }
4061
4062 /*
4063  * Added by Keith Kanios:
4064  *
4065  * This function is used to assist with "runtime" preprocessor
4066  * directives. (e.g. pp_runtime("%define __BITS__ 64");)
4067  *
4068  * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
4069  * PASS A VALID STRING TO THIS FUNCTION!!!!!
4070  */
4071
4072 void pp_runtime(char *definition)
4073 {
4074     Token *def;
4075
4076     def = tokenize(definition);
4077     if(do_directive(def) == NO_DIRECTIVE_FOUND)
4078         free_tlist(def);
4079
4080 }
4081
4082 void pp_extra_stdmac(const char **macros)
4083 {
4084     extrastdmac = macros;
4085 }
4086
4087 static void make_tok_num(Token * tok, int64_t val)
4088 {
4089     char numbuf[20];
4090     snprintf(numbuf, sizeof(numbuf), "%"PRId64"", val);
4091     tok->text = nasm_strdup(numbuf);
4092     tok->type = TOK_NUMBER;
4093 }
4094
4095 Preproc nasmpp = {
4096     pp_reset,
4097     pp_getline,
4098     pp_cleanup
4099 };