Logo Search packages:      
Sourcecode: yasm version File versions  Download package

nasm-pp.c

/* -*- mode: c; c-file-style: "bsd" -*- */
/* preproc.c   macro preprocessor for the Netwide Assembler
 *
 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
 * Julian Hall. All rights reserved. The software is
 * redistributable under the licence given in the file "Licence"
 * distributed in the NASM archive.
 *
 * initial version 18/iii/97 by Simon Tatham
 */

/* Typical flow of text through preproc
 *
 * pp_getline gets tokenised lines, either
 *
 *   from a macro expansion
 *
 * or
 *   {
 *   read_line  gets raw text from stdmacpos, or predef, or current input file
 *   tokenise   converts to tokens
 *   }
 *
 * expand_mmac_params is used to expand %1 etc., unless a macro is being
 * defined or a false conditional is being processed
 * (%0, %1, %+1, %-1, %%foo
 *
 * do_directive checks for directives
 *
 * expand_smacro is used to expand single line macros
 *
 * expand_mmacro is used to expand multi-line macros
 *
 * detoken is used to convert the line back to text
 */
#include <util.h>
#include <libyasm/coretype.h>
#include <stdarg.h>
#include <ctype.h>
#include <limits.h>

#include "nasm.h"
#include "nasmlib.h"
#include "nasm-pp.h"

typedef struct SMacro SMacro;
typedef struct MMacro MMacro;
typedef struct Context Context;
typedef struct Token Token;
typedef struct Blocks Blocks;
typedef struct Line Line;
typedef struct Include Include;
typedef struct Cond Cond;
typedef struct IncPath IncPath;

/*
 * Store the definition of a single-line macro.
 */
struct SMacro
{
    SMacro *next;
    char *name;
    int casesense;
    int nparam;
    int in_progress;
    Token *expansion;
};

/*
 * Store the definition of a multi-line macro. This is also used to
 * store the interiors of `%rep...%endrep' blocks, which are
 * effectively self-re-invoking multi-line macros which simply
 * don't have a name or bother to appear in the hash tables. %rep
 * blocks are signified by having a NULL `name' field.
 *
 * In a MMacro describing a `%rep' block, the `in_progress' field
 * isn't merely boolean, but gives the number of repeats left to
 * run.
 *
 * The `next' field is used for storing MMacros in hash tables; the
 * `next_active' field is for stacking them on istk entries.
 *
 * When a MMacro is being expanded, `params', `iline', `nparam',
 * `paramlen', `rotate' and `unique' are local to the invocation.
 */
struct MMacro
{
    MMacro *next;
    char *name;
    int casesense;
    int nparam_min, nparam_max;
    int plus;                 /* is the last parameter greedy? */
    int nolist;               /* is this macro listing-inhibited? */
    int in_progress;
    Token *dlist;       /* All defaults as one list */
    Token **defaults;         /* Parameter default pointers */
    int ndefs;                /* number of default parameters */
    Line *expansion;

    MMacro *next_active;
    MMacro *rep_nest;         /* used for nesting %rep */
    Token **params;           /* actual parameters */
    Token *iline;       /* invocation line */
    int nparam, rotate, *paramlen;
    unsigned long unique;
    int lineno;               /* Current line number on expansion */
};

/*
 * The context stack is composed of a linked list of these.
 */
struct Context
{
    Context *next;
    SMacro *localmac;
    char *name;
    unsigned long number;
};

/*
 * This is the internal form which we break input lines up into.
 * Typically stored in linked lists.
 *
 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
 * necessarily used as-is, but is intended to denote the number of
 * the substituted parameter. So in the definition
 *
 *     %define a(x,y) ( (x) & ~(y) )
 * 
 * the token representing `x' will have its type changed to
 * TOK_SMAC_PARAM, but the one representing `y' will be
 * TOK_SMAC_PARAM+1.
 *
 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
 * which doesn't need quotes around it. Used in the pre-include
 * mechanism as an alternative to trying to find a sensible type of
 * quote to use on the filename we were passed.
 */
struct Token
{
    Token *next;
    char *text;
    SMacro *mac;        /* associated macro for TOK_SMAC_END */
    int type;
};
enum
{
    TOK_WHITESPACE = 1, TOK_COMMENT, TOK_ID, TOK_PREPROC_ID, TOK_STRING,
    TOK_NUMBER, TOK_SMAC_END, TOK_OTHER, TOK_SMAC_PARAM,
    TOK_INTERNAL_STRING
};

/*
 * Multi-line macro definitions are stored as a linked list of
 * these, which is essentially a container to allow several linked
 * lists of Tokens.
 * 
 * Note that in this module, linked lists are treated as stacks
 * wherever possible. For this reason, Lines are _pushed_ on to the
 * `expansion' field in MMacro structures, so that the linked list,
 * if walked, would give the macro lines in reverse order; this
 * means that we can walk the list when expanding a macro, and thus
 * push the lines on to the `expansion' field in _istk_ in reverse
 * order (so that when popped back off they are in the right
 * order). It may seem cockeyed, and it relies on my design having
 * an even number of steps in, but it works...
 *
 * Some of these structures, rather than being actual lines, are
 * markers delimiting the end of the expansion of a given macro.
 * This is for use in the cycle-tracking and %rep-handling code.
 * Such structures have `finishes' non-NULL, and `first' NULL. All
 * others have `finishes' NULL, but `first' may still be NULL if
 * the line is blank.
 */
struct Line
{
    Line *next;
    MMacro *finishes;
    Token *first;
};

/*
 * To handle an arbitrary level of file inclusion, we maintain a
 * stack (ie linked list) of these things.
 */
struct Include
{
    Include *next;
    FILE *fp;
    Cond *conds;
    Line *expansion;
    char *fname;
    int lineno, lineinc;
    MMacro *mstk;       /* stack of active macros/reps */
};

/*
 * Include search path. This is simply a list of strings which get
 * prepended, in turn, to the name of an include file, in an
 * attempt to find the file if it's not in the current directory.
 */
struct IncPath
{
    IncPath *next;
    char *path;
};

/*
 * Conditional assembly: we maintain a separate stack of these for
 * each level of file inclusion. (The only reason we keep the
 * stacks separate is to ensure that a stray `%endif' in a file
 * included from within the true branch of a `%if' won't terminate
 * it and cause confusion: instead, rightly, it'll cause an error.)
 */
struct Cond
{
    Cond *next;
    int state;
};
enum
{
    /*
     * These states are for use just after %if or %elif: IF_TRUE
     * means the condition has evaluated to truth so we are
     * currently emitting, whereas IF_FALSE means we are not
     * currently emitting but will start doing so if a %else comes
     * up. In these states, all directives are admissible: %elif,
     * %else and %endif. (And of course %if.)
     */
    COND_IF_TRUE, COND_IF_FALSE,
    /*
     * These states come up after a %else: ELSE_TRUE means we're
     * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
     * any %elif or %else will cause an error.
     */
    COND_ELSE_TRUE, COND_ELSE_FALSE,
    /*
     * This state means that we're not emitting now, and also that
     * nothing until %endif will be emitted at all. It's for use in
     * two circumstances: (i) when we've had our moment of emission
     * and have now started seeing %elifs, and (ii) when the
     * condition construct in question is contained within a
     * non-emitting branch of a larger condition construct.
     */
    COND_NEVER
};
#define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )

/* 
 * These defines are used as the possible return values for do_directive
 */
#define NO_DIRECTIVE_FOUND  0
#define DIRECTIVE_FOUND     1

/*
 * Condition codes. Note that we use c_ prefix not C_ because C_ is
 * used in nasm.h for the "real" condition codes. At _this_ level,
 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
 * ones, so we need a different enum...
 */
static const char *conditions[] = {
    "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
    "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
    "np", "ns", "nz", "o", "p", "pe", "po", "s", "z"
};
enum
{
    c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE,
    c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO,
    c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_S, c_Z
};
static int inverse_ccs[] = {
    c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE,
    c_A, c_AE, c_B, c_BE, c_C, c_E, c_G, c_GE, c_L, c_LE, c_O, c_P, c_S,
    c_Z, c_NO, c_NP, c_PO, c_PE, c_NS, c_NZ
};

/*
 * Directive names.
 */
static const char *directives[] = {
    "%arg",
    "%assign", "%clear", "%define", "%elif", "%elifctx", "%elifdef",
    "%elifid", "%elifidn", "%elifidni", "%elifmacro", "%elifnctx", "%elifndef",
    "%elifnid", "%elifnidn", "%elifnidni", "%elifnmacro", "%elifnnum", "%elifnstr",
    "%elifnum", "%elifstr", "%else", "%endif", "%endm", "%endmacro",
    "%endrep", "%error", "%exitrep", "%iassign", "%idefine", "%if",
    "%ifctx", "%ifdef", "%ifid", "%ifidn", "%ifidni", "%ifmacro", "%ifnctx",
    "%ifndef", "%ifnid", "%ifnidn", "%ifnidni", "%ifnmacro", "%ifnnum",
    "%ifnstr", "%ifnum", "%ifstr", "%imacro", "%include",
    "%ixdefine", "%line",
    "%local",
    "%macro", "%pop", "%push", "%rep", "%repl", "%rotate",
    "%stacksize",
    "%strlen", "%substr", "%undef", "%xdefine"
};
enum
{
    PP_ARG,
    PP_ASSIGN, PP_CLEAR, PP_DEFINE, PP_ELIF, PP_ELIFCTX, PP_ELIFDEF,
    PP_ELIFID, PP_ELIFIDN, PP_ELIFIDNI, PP_ELIFMACRO, PP_ELIFNCTX, PP_ELIFNDEF,
    PP_ELIFNID, PP_ELIFNIDN, PP_ELIFNIDNI, PP_ELIFNMACRO, PP_ELIFNNUM, PP_ELIFNSTR,
    PP_ELIFNUM, PP_ELIFSTR, PP_ELSE, PP_ENDIF, PP_ENDM, PP_ENDMACRO,
    PP_ENDREP, PP_ERROR, PP_EXITREP, PP_IASSIGN, PP_IDEFINE, PP_IF,
    PP_IFCTX, PP_IFDEF, PP_IFID, PP_IFIDN, PP_IFIDNI, PP_IFMACRO, PP_IFNCTX,
    PP_IFNDEF, PP_IFNID, PP_IFNIDN, PP_IFNIDNI, PP_IFNMACRO, PP_IFNNUM,
    PP_IFNSTR, PP_IFNUM, PP_IFSTR, PP_IMACRO, PP_INCLUDE,
    PP_IXDEFINE, PP_LINE,
    PP_LOCAL,
    PP_MACRO, PP_POP, PP_PUSH, PP_REP, PP_REPL, PP_ROTATE,
    PP_STACKSIZE,
    PP_STRLEN, PP_SUBSTR, PP_UNDEF, PP_XDEFINE
};

/* If this is a an IF, ELIF, ELSE or ENDIF keyword */
static int is_condition(int arg)
{
    return ((arg >= PP_ELIF) && (arg <= PP_ENDIF)) ||
      ((arg >= PP_IF) && (arg <= PP_IFSTR));
}

/* For TASM compatibility we need to be able to recognise TASM compatible
 * conditional compilation directives. Using the NASM pre-processor does
 * not work, so we look for them specifically from the following list and
 * then jam in the equivalent NASM directive into the input stream.
 */

#ifndef MAX
#       define MAX(a,b) ( ((a) > (b)) ? (a) : (b))
#endif

enum
{
    TM_ARG, TM_ELIF, TM_ELSE, TM_ENDIF, TM_IF, TM_IFDEF, TM_IFDIFI,
    TM_IFNDEF, TM_INCLUDE, TM_LOCAL
};

static const char *tasm_directives[] = {
    "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
    "ifndef", "include", "local"
};

static int StackSize = 4;
static const char *StackPointer = "ebp";
static int ArgOffset = 8;
static int LocalOffset = 4;


static Context *cstk;
static Include *istk;
static IncPath *ipath = NULL;

static FILE *first_fp = NULL;

static efunc _error;          /* Pointer to client-provided error reporting function */
static evalfunc evaluate;

static int pass;        /* HACK: pass 0 = generate dependencies only */

static unsigned long unique;  /* unique identifier numbers */

static Line *predef = NULL;

static ListGen *list;

/*
 * The number of hash values we use for the macro lookup tables.
 * FIXME: We should *really* be able to configure this at run time,
 * or even have the hash table automatically expanding when necessary.
 */
#define NHASH 31

/*
 * The current set of multi-line macros we have defined.
 */
static MMacro *mmacros[NHASH];

/*
 * The current set of single-line macros we have defined.
 */
static SMacro *smacros[NHASH];

/*
 * The multi-line macro we are currently defining, or the %rep
 * block we are currently reading, if any.
 */
static MMacro *defining;

/*
 * The number of macro parameters to allocate space for at a time.
 */
#define PARAM_DELTA 16

/*
 * The standard macro set: defined as `static char *stdmac[]'. Also
 * gives our position in the macro set, when we're processing it.
 */
#include "nasm-macros.c"
static const char **stdmacpos;

/*
 * The extra standard macros that come from the object format, if
 * any.
 */
static const char **extrastdmac = NULL;
int any_extrastdmac;

/*
 * Tokens are allocated in blocks to improve speed
 */
#define TOKEN_BLOCKSIZE 4096
static Token *freeTokens = NULL;
struct Blocks {
      Blocks *next;
      void *chunk;
};

static Blocks blocks = { NULL, NULL };

/*
 * Forward declarations.
 */
static Token *expand_mmac_params(Token * tline);
static Token *expand_smacro(Token * tline);
static Token *expand_id(Token * tline);
static Context *get_ctx(char *name, int all_contexts);
static void make_tok_num(Token * tok, long val);
static void error(int severity, const char *fmt, ...);
static void *new_Block(size_t size);
static void delete_Blocks(void);
static Token *new_Token(Token * next, int type, const char *text, int txtlen);
static Token *delete_Token(Token * t);

/*
 * Macros for safe checking of token pointers, avoid *(NULL)
 */
#define tok_type_(x,t) ((x) && (x)->type == (t))
#define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
#define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
#define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))

/* Handle TASM specific directives, which do not contain a % in
 * front of them. We do it here because I could not find any other
 * place to do it for the moment, and it is a hack (ideally it would
 * be nice to be able to use the NASM pre-processor to do it).
 */
static char *
check_tasm_directive(char *line)
{
    int i, j, k, m;
    size_t len;
    char *p = line, *oldline, oldchar;

    /* Skip whitespace */
    while (isspace(*p) && *p != 0)
      p++;

    /* Binary search for the directive name */
    i = -1;
    j = elements(tasm_directives);
    len = 0;
    while (!isspace(p[len]) && p[len] != 0)
      len++;
    if (len)
    {
      oldchar = p[len];
      p[len] = 0;
      while (j - i > 1)
      {
          k = (j + i) / 2;
          m = nasm_stricmp(p, tasm_directives[k]);
          if (m == 0)
          {
            /* We have found a directive, so jam a % in front of it
             * so that NASM will then recognise it as one if it's own.
             */
            p[len] = oldchar;
            len = strlen(p);
            oldline = line;
            line = nasm_malloc(len + 2);
            line[0] = '%';
            if (k == TM_IFDIFI)
            {
                /* NASM does not recognise IFDIFI, so we convert it to
                 * %ifdef BOGUS. This is not used in NASM comaptible
                 * code, but does need to parse for the TASM macro
                 * package.
                 */
                strcpy(line + 1, "ifdef BOGUS");
            }
            else
            {
                memcpy(line + 1, p, len + 1);
            }
            nasm_free(oldline);
            return line;
          }
          else if (m < 0)
          {
            j = k;
          }
          else
            i = k;
      }
      p[len] = oldchar;
    }
    return line;
}

/*
 * The pre-preprocessing stage... This function translates line
 * number indications as they emerge from GNU cpp (`# lineno "file"
 * flags') into NASM preprocessor line number indications (`%line
 * lineno file').
 */
static char *
prepreproc(char *line)
{
    int lineno;
    size_t fnlen;
    char *fname, *oldline;

    if (line[0] == '#' && line[1] == ' ')
    {
      oldline = line;
      fname = oldline + 2;
      lineno = atoi(fname);
      fname += strspn(fname, "0123456789 ");
      if (*fname == '"')
          fname++;
      fnlen = strcspn(fname, "\"");
      line = nasm_malloc(20 + fnlen);
      sprintf(line, "%%line %d %.*s", lineno, (int)fnlen, fname);
      nasm_free(oldline);
    }
    if (tasm_compatible_mode)
      return check_tasm_directive(line);
    return line;
}

/*
 * The hash function for macro lookups. Note that due to some
 * macros having case-insensitive names, the hash function must be
 * invariant under case changes. We implement this by applying a
 * perfectly normal hash function to the uppercase of the string.
 */
static int
hash(char *s)
{
    unsigned int h = 0;
    unsigned int i = 0;
    /*
     * Powers of three, mod 31.
     */
    static const int multipliers[] = {
      1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10,
      30, 28, 22, 4, 12, 5, 15, 14, 11, 2, 6, 18, 23, 7, 21
    };


    while (*s)
    {
      h += multipliers[i] * (unsigned char) (toupper(*s));
      s++;
      if (++i >= elements(multipliers))
          i = 0;
    }
    h %= NHASH;
    return h;
}

/*
 * Free a linked list of tokens.
 */
static void
free_tlist(Token * list_)
{
    while (list_)
    {
      list_ = delete_Token(list_);
    }
}

/*
 * Free a linked list of lines.
 */
static void
free_llist(Line * list_)
{
    Line *l;
    while (list_)
    {
      l = list_;
      list_ = list_->next;
      free_tlist(l->first);
      nasm_free(l);
    }
}

/*
 * Free an MMacro
 */
static void
free_mmacro(MMacro * m)
{
    nasm_free(m->name);
    free_tlist(m->dlist);
    nasm_free(m->defaults);
    free_llist(m->expansion);
    nasm_free(m);
}

/*
 * Pop the context stack.
 */
static void
ctx_pop(void)
{
    Context *c = cstk;
    SMacro *smac, *s;

    cstk = cstk->next;
    smac = c->localmac;
    while (smac)
    {
      s = smac;
      smac = smac->next;
      nasm_free(s->name);
      free_tlist(s->expansion);
      nasm_free(s);
    }
    nasm_free(c->name);
    nasm_free(c);
}

#define BUF_DELTA 512
/*
 * Read a line from the top file in istk, handling multiple CR/LFs
 * at the end of the line read, and handling spurious ^Zs. Will
 * return lines from the standard macro set if this has not already
 * been done.
 */
static char *
read_line(void)
{
    char *buffer, *p, *q;
    int bufsize, continued_count;

    if (stdmacpos)
    {
      if (*stdmacpos)
      {
          char *ret = nasm_strdup(*stdmacpos++);
          if (!*stdmacpos && any_extrastdmac)
          {
            stdmacpos = extrastdmac;
            any_extrastdmac = FALSE;
            return ret;
          }
          /*
           * Nasty hack: here we push the contents of `predef' on
           * to the top-level expansion stack, since this is the
           * most convenient way to implement the pre-include and
           * pre-define features.
           */
          if (!*stdmacpos)
          {
            Line *pd, *l;
            Token *head, **tail, *t;

            for (pd = predef; pd; pd = pd->next)
            {
                head = NULL;
                tail = &head;
                for (t = pd->first; t; t = t->next)
                {
                  *tail = new_Token(NULL, t->type, t->text, 0);
                  tail = &(*tail)->next;
                }
                l = nasm_malloc(sizeof(Line));
                l->next = istk->expansion;
                l->first = head;
                l->finishes = FALSE;
                istk->expansion = l;
            }
          }
          return ret;
      }
      else
      {
          stdmacpos = NULL;
      }
    }

    bufsize = BUF_DELTA;
    buffer = nasm_malloc(BUF_DELTA);
    p = buffer;
    continued_count = 0;
    while (1)
    {
      q = fgets(p, bufsize - (p - buffer), istk->fp);
      if (!q)
          break;
      p += strlen(p);
      if (p > buffer && p[-1] == '\n')
      {
           /* Convert backslash-CRLF line continuation sequences into
              nothing at all (for DOS and Windows) */
           if (((p - 2) > buffer) && (p[-3] == '\\') && (p[-2] == '\r')) {
               p -= 3;
               *p = 0;
               continued_count++;
           }
           /* Also convert backslash-LF line continuation sequences into
              nothing at all (for Unix) */
           else if (((p - 1) > buffer) && (p[-2] == '\\')) {
               p -= 2;
               *p = 0;
               continued_count++;
           }
           else {
               break;
           }
      }
      if (p - buffer > bufsize - 10)
      {
          long offset = p - buffer;
          bufsize += BUF_DELTA;
          buffer = nasm_realloc(buffer, (size_t)bufsize);
          p = buffer + offset;      /* prevent stale-pointer problems */
      }
    }

    if (!q && p == buffer)
    {
      nasm_free(buffer);
      return NULL;
    }

    nasm_src_set_linnum(nasm_src_get_linnum() + istk->lineinc + (continued_count * istk->lineinc));

    /*
     * Play safe: remove CRs as well as LFs, if any of either are
     * present at the end of the line.
     */
    while (--p >= buffer && (*p == '\n' || *p == '\r'))
      *p = '\0';

    /*
     * Handle spurious ^Z, which may be inserted into source files
     * by some file transfer utilities.
     */
    buffer[strcspn(buffer, "\032")] = '\0';

    list->line(LIST_READ, buffer);

    return buffer;
}

/*
 * Tokenise a line of text. This is a very simple process since we
 * don't need to parse the value out of e.g. numeric tokens: we
 * simply split one string into many.
 */
static Token *
tokenise(char *line)
{
    char *p = line;
    int type;
    Token *list_ = NULL;
    Token *t, **tail = &list_;

    while (*line)
    {
      p = line;
      if (*p == '%')
      {
            p++;
            if ( isdigit(*p) ||
                  ((*p == '-' || *p == '+') && isdigit(p[1])) ||
                  ((*p == '+') && (isspace(p[1]) || !p[1])))
                        {
                  do
                  {
                  p++;
                  }
                  while (isdigit(*p));
                  type = TOK_PREPROC_ID;
            }
            else if (*p == '{')
            {
                  p++;
                  while (*p && *p != '}')
                  {
                  p[-1] = *p;
                  p++;
                  }
                  p[-1] = '\0';
                  if (*p)
                  p++;
                  type = TOK_PREPROC_ID;
            }
            else if (isidchar(*p) ||
                        ((*p == '!' || *p == '%' || *p == '$') &&
                              isidchar(p[1])))
            {
                  do
                  {
                  p++;
                  }
                  while (isidchar(*p));
                  type = TOK_PREPROC_ID;
            }
            else
            {
                  type = TOK_OTHER;
                  if (*p == '%')
                        p++;
            }
      }
      else if (isidstart(*p) || (*p == '$' && isidstart(p[1])))
      {
          type = TOK_ID;
          p++;
          while (*p && isidchar(*p))
            p++;
      }
      else if (*p == '\'' || *p == '"')
      {
          /*
           * A string token.
           */
          char c = *p;
          p++;
          type = TOK_STRING;
          while (*p && *p != c)
            p++;

          if (*p)
          {
            p++;
          }
          else
          {
            error(ERR_WARNING, "unterminated string");
            type = -1;
          }
      }
      else if (isnumstart(*p))
      {
          /*
           * A number token.
           */
          type = TOK_NUMBER;
          p++;
          while (*p && isnumchar(*p))
            p++;
      }
      else if (isspace(*p))
      {
          type = TOK_WHITESPACE;
          p++;
          while (*p && isspace(*p))
            p++;
          /*
           * Whitespace just before end-of-line is discarded by
           * pretending it's a comment; whitespace just before a
           * comment gets lumped into the comment.
           */
          if (!*p || *p == ';')
          {
            type = TOK_COMMENT;
            while (*p)
                p++;
          }
      }
      else if (*p == ';')
      {
          type = TOK_COMMENT;
          while (*p)
            p++;
      }
      else
      {
          /*
           * Anything else is an operator of some kind. We check
           * for all the double-character operators (>>, <<, //,
           * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
           * else is a single-character operator.
           */
          type = TOK_OTHER;
          if ((p[0] == '>' && p[1] == '>') ||
                (p[0] == '<' && p[1] == '<') ||
                (p[0] == '/' && p[1] == '/') ||
                (p[0] == '<' && p[1] == '=') ||
                (p[0] == '>' && p[1] == '=') ||
                (p[0] == '=' && p[1] == '=') ||
                (p[0] == '!' && p[1] == '=') ||
                (p[0] == '<' && p[1] == '>') ||
                (p[0] == '&' && p[1] == '&') ||
                (p[0] == '|' && p[1] == '|') ||
                (p[0] == '^' && p[1] == '^'))
          {
            p++;
          }
          p++;
      }

      /* Handle unterminated string */
      if (type == -1)
      {
          *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
          t->text[p-line] = *line;
          tail = &t->next;
      }
      else if (type != TOK_COMMENT)
      {
          *tail = t = new_Token(NULL, type, line, p - line);
          tail = &t->next;
      }
      line = p;
    }
    return list_;
}

/*
 * this function allocates a new managed block of memory and
 * returns a pointer to the block.  The managed blocks are 
 * deleted only all at once by the delete_Blocks function.
 */
static void *
new_Block(size_t size)
{
      Blocks *b = &blocks;
      
      /* first, get to the end of the linked list      */
      while (b->next)
            b = b->next;
      /* now allocate the requested chunk */
      b->chunk = nasm_malloc(size);
      
      /* now allocate a new block for the next request */
      b->next = nasm_malloc(sizeof(Blocks));
      /* and initialize the contents of the new block */
      b->next->next = NULL;
      b->next->chunk = NULL;
      return b->chunk;
}

/*
 * this function deletes all managed blocks of memory
 */
static void
delete_Blocks(void)
{
      Blocks *a,*b = &blocks;

      /* 
       * keep in mind that the first block, pointed to by blocks
       * is a static and not dynamically allocated, so we don't 
       * free it.
       */
      while (b)
      {
            if (b->chunk)
                  nasm_free(b->chunk);
            a = b;
            b = b->next;
                if (a != &blocks)
                  nasm_free(a);
      }
}     

/*
 *  this function creates a new Token and passes a pointer to it 
 *  back to the caller.  It sets the type and text elements, and
 *  also the mac and next elements to NULL.
 */
static Token *
new_Token(Token * next, int type, const char *text, int txtlen)
{
    Token *t;
    int i;

    if (freeTokens == NULL)
    {
      freeTokens = (Token *)new_Block(TOKEN_BLOCKSIZE * sizeof(Token));
      for (i = 0; i < TOKEN_BLOCKSIZE - 1; i++)
          freeTokens[i].next = &freeTokens[i + 1];
      freeTokens[i].next = NULL;
    }
    t = freeTokens;
    freeTokens = t->next;
    t->next = next;
    t->mac = NULL;
    t->type = type;
    if (type == TOK_WHITESPACE || text == NULL)
    {
      t->text = NULL;
    }
    else
    {
      if (txtlen == 0)
          txtlen = strlen(text);
      t->text = nasm_malloc(1 + (size_t)txtlen);
      strncpy(t->text, text, (size_t)txtlen);
      t->text[txtlen] = '\0';
    }
    return t;
}

static Token *
delete_Token(Token * t)
{
    Token *next = t->next;
    nasm_free(t->text);
    t->next = freeTokens;
    freeTokens = t;
    return next;
}

/*
 * Convert a line of tokens back into text.
 * If expand_locals is not zero, identifiers of the form "%$*xxx"
 * will be transformed into ..@ctxnum.xxx
 */
static char *
detoken(Token * tlist, int expand_locals)
{
    Token *t;
    int len;
    char *line, *p;

    len = 0;
    for (t = tlist; t; t = t->next)
    {
      if (t->type == TOK_PREPROC_ID && t->text[1] == '!')
      {
          char *p2 = getenv(t->text + 2);
          nasm_free(t->text);
          if (p2)
            t->text = nasm_strdup(p2);
          else
            t->text = NULL;
      }
      /* Expand local macros here and not during preprocessing */
      if (expand_locals &&
            t->type == TOK_PREPROC_ID && t->text &&
            t->text[0] == '%' && t->text[1] == '$')
      {
          Context *ctx = get_ctx(t->text, FALSE);
          if (ctx)
          {
            char buffer[40];
            char *p2, *q = t->text + 2;

            q += strspn(q, "$");
            sprintf(buffer, "..@%lu.", ctx->number);
            p2 = nasm_strcat(buffer, q);
            nasm_free(t->text);
            t->text = p2;
          }
      }
      if (t->type == TOK_WHITESPACE)
      {
          len++;
      }
      else if (t->text)
      {
          len += strlen(t->text);
      }
    }
    p = line = nasm_malloc((size_t)len + 1);
    for (t = tlist; t; t = t->next)
    {
      if (t->type == TOK_WHITESPACE)
      {
          *p = ' ';
            p++;
            *p = '\0';
      }
      else if (t->text)
      {
          strcpy(p, t->text);
          p += strlen(p);
      }
    }
    *p = '\0';
    return line;
}

/*
 * A scanner, suitable for use by the expression evaluator, which
 * operates on a line of Tokens. Expects a pointer to a pointer to
 * the first token in the line to be passed in as its private_data
 * field.
 */
static int
ppscan(void *private_data, struct tokenval *tokval)
{
    Token **tlineptr = private_data;
    Token *tline;

    do
    {
      tline = *tlineptr;
      *tlineptr = tline ? tline->next : NULL;
    }
    while (tline && (tline->type == TOK_WHITESPACE ||
                tline->type == TOK_COMMENT));

    if (!tline)
      return tokval->t_type = TOKEN_EOS;

    if (tline->text[0] == '$' && !tline->text[1])
      return tokval->t_type = TOKEN_HERE;
    if (tline->text[0] == '$' && tline->text[1] == '$' && !tline->text[2])
      return tokval->t_type = TOKEN_BASE;

    if (tline->type == TOK_ID)
    {
      tokval->t_charptr = tline->text;
      if (tline->text[0] == '$')
      {
          tokval->t_charptr++;
          return tokval->t_type = TOKEN_ID;
      }

      /*
       * This is the only special case we actually need to worry
       * about in this restricted context.
       */
      if (!nasm_stricmp(tline->text, "seg"))
          return tokval->t_type = TOKEN_SEG;

      return tokval->t_type = TOKEN_ID;
    }

    if (tline->type == TOK_NUMBER)
    {
      int rn_error;

      tokval->t_integer = nasm_readnum(tline->text, &rn_error);
      if (rn_error)
          return tokval->t_type = TOKEN_ERRNUM;
      tokval->t_charptr = NULL;
      return tokval->t_type = TOKEN_NUM;
    }

    if (tline->type == TOK_STRING)
    {
      int rn_warn;
      char q, *r;
      int l;

      r = tline->text;
      q = *r++;
      l = strlen(r);

      if (l == 0 || r[l - 1] != q)
          return tokval->t_type = TOKEN_ERRNUM;
      tokval->t_integer = nasm_readstrnum(r, l - 1, &rn_warn);
      if (rn_warn)
          error(ERR_WARNING | ERR_PASS1, "character constant too long");
      tokval->t_charptr = NULL;
      return tokval->t_type = TOKEN_NUM;
    }

    if (tline->type == TOK_OTHER)
    {
      if (!strcmp(tline->text, "<<"))
          return tokval->t_type = TOKEN_SHL;
      if (!strcmp(tline->text, ">>"))
          return tokval->t_type = TOKEN_SHR;
      if (!strcmp(tline->text, "//"))
          return tokval->t_type = TOKEN_SDIV;
      if (!strcmp(tline->text, "%%"))
          return tokval->t_type = TOKEN_SMOD;
      if (!strcmp(tline->text, "=="))
          return tokval->t_type = TOKEN_EQ;
      if (!strcmp(tline->text, "<>"))
          return tokval->t_type = TOKEN_NE;
      if (!strcmp(tline->text, "!="))
          return tokval->t_type = TOKEN_NE;
      if (!strcmp(tline->text, "<="))
          return tokval->t_type = TOKEN_LE;
      if (!strcmp(tline->text, ">="))
          return tokval->t_type = TOKEN_GE;
      if (!strcmp(tline->text, "&&"))
          return tokval->t_type = TOKEN_DBL_AND;
      if (!strcmp(tline->text, "^^"))
          return tokval->t_type = TOKEN_DBL_XOR;
      if (!strcmp(tline->text, "||"))
          return tokval->t_type = TOKEN_DBL_OR;
    }

    /*
     * We have no other options: just return the first character of
     * the token text.
     */
    return tokval->t_type = tline->text[0];
}

/*
 * Compare a string to the name of an existing macro; this is a
 * simple wrapper which calls either strcmp or nasm_stricmp
 * depending on the value of the `casesense' parameter.
 */
static int
mstrcmp(char *p, char *q, int casesense)
{
    return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
}

/*
 * Return the Context structure associated with a %$ token. Return
 * NULL, having _already_ reported an error condition, if the
 * context stack isn't deep enough for the supplied number of $
 * signs.
 * If all_contexts == TRUE, contexts that enclose current are
 * also scanned for such smacro, until it is found; if not -
 * only the context that directly results from the number of $'s
 * in variable's name.
 */
static Context *
get_ctx(char *name, int all_contexts)
{
    Context *ctx;
    SMacro *m;
    int i;

    if (!name || name[0] != '%' || name[1] != '$')
      return NULL;

    if (!cstk)
    {
      error(ERR_NONFATAL, "`%s': context stack is empty", name);
      return NULL;
    }

    for (i = strspn(name + 2, "$"), ctx = cstk; (i > 0) && ctx; i--)
    {
      ctx = ctx->next;
/*        i--;  Lino - 02/25/02 */
    }
    if (!ctx)
    {
      error(ERR_NONFATAL, "`%s': context stack is only"
            " %d level%s deep", name, i - 1, (i == 2 ? "" : "s"));
      return NULL;
    }
    if (!all_contexts)
      return ctx;

    do
    {
      /* Search for this smacro in found context */
      m = ctx->localmac;
      while (m)
      {
          if (!mstrcmp(m->name, name, m->casesense))
            return ctx;
          m = m->next;
      }
      ctx = ctx->next;
    }
    while (ctx);
    return NULL;
}

/* Add a slash to the end of a path if it is missing. We use the
 * forward slash to make it compatible with Unix systems.
 */
static void
backslash(char *s)
{
    int pos = strlen(s);
    if (s[pos - 1] != '\\' && s[pos - 1] != '/')
    {
      s[pos] = '/';
      s[pos + 1] = '\0';
    }
}

/*
 * Open an include file. This routine must always return a valid
 * file pointer if it returns - it's responsible for throwing an
 * ERR_FATAL and bombing out completely if not. It should also try
 * the include path one by one until it finds the file or reaches
 * the end of the path.
 */
static FILE *
inc_fopen(char *file)
{
    FILE *fp;
    const char *prefix = "";
    char *combine;
    IncPath *ip = ipath;
    static int namelen = 0;
    int len = strlen(file);

    while (1)
    {
      combine = nasm_malloc(strlen(prefix) + 1 + len + 1);
      strcpy(combine, prefix);
      if (prefix[0] != 0)
          backslash(combine);
      strcat(combine, file);
      fp = fopen(combine, "r");
      if (pass == 0 && fp)
      {
          namelen += strlen(combine) + 1;
          if (namelen > 62)
          {
            printf(" \\\n  ");
            namelen = 2;
          }
          printf(" %s", combine);
      }
      nasm_free(combine);
      if (fp)
          return fp;
      if (!ip)
          break;
      prefix = ip->path;
      ip = ip->next;
    }

    error(ERR_FATAL, "unable to open include file `%s'", file);
    return NULL;        /* never reached - placate compilers */
}

/*
 * Determine if we should warn on defining a single-line macro of
 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
 * return TRUE if _any_ single-line macro of that name is defined.
 * Otherwise, will return TRUE if a single-line macro with either
 * `nparam' or no parameters is defined.
 *
 * If a macro with precisely the right number of parameters is
 * defined, or nparam is -1, the address of the definition structure
 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
 * is NULL, no action will be taken regarding its contents, and no
 * error will occur.
 *
 * Note that this is also called with nparam zero to resolve
 * `ifdef'.
 *
 * If you already know which context macro belongs to, you can pass
 * the context pointer as first parameter; if you won't but name begins
 * with %$ the context will be automatically computed. If all_contexts
 * is true, macro will be searched in outer contexts as well.
 */
static int
smacro_defined(Context * ctx, char *name, int nparam, SMacro ** defn,
      int nocase)
{
    SMacro *m;

    if (ctx)
      m = ctx->localmac;
    else if (name[0] == '%' && name[1] == '$')
    {
      if (cstk)
          ctx = get_ctx(name, FALSE);
      if (!ctx)
          return FALSE; /* got to return _something_ */
      m = ctx->localmac;
    }
    else
      m = smacros[hash(name)];

    while (m)
    {
      if (!mstrcmp(m->name, name, m->casesense && nocase) &&
            (nparam <= 0 || m->nparam == 0 || nparam == m->nparam))
      {
          if (defn)
          {
            if (nparam == m->nparam || nparam == -1)
                *defn = m;
            else
                *defn = NULL;
          }
          return TRUE;
      }
      m = m->next;
    }

    return FALSE;
}

/*
 * Count and mark off the parameters in a multi-line macro call.
 * This is called both from within the multi-line macro expansion
 * code, and also to mark off the default parameters when provided
 * in a %macro definition line.
 */
static void
count_mmac_params(Token * t, int *nparam, Token *** params)
{
    int paramsize, brace;

    *nparam = paramsize = 0;
    *params = NULL;
    while (t)
    {
      if (*nparam >= paramsize)
      {
          paramsize += PARAM_DELTA;
          *params = nasm_realloc(*params, sizeof(**params) * paramsize);
      }
      skip_white_(t);
      brace = FALSE;
      if (tok_is_(t, "{"))
          brace = TRUE;
      (*params)[(*nparam)++] = t;
      while (tok_isnt_(t, brace ? "}" : ","))
          t = t->next;
      if (t)
      {                 /* got a comma/brace */
          t = t->next;
          if (brace)
          {
            /*
             * Now we've found the closing brace, look further
             * for the comma.
             */
            skip_white_(t);
            if (tok_isnt_(t, ","))
            {
                error(ERR_NONFATAL,
                      "braces do not enclose all of macro parameter");
                while (tok_isnt_(t, ","))
                  t = t->next;
            }
            if (t)
                t = t->next;  /* eat the comma */
          }
      }
    }
}

/*
 * Determine whether one of the various `if' conditions is true or
 * not.
 *
 * We must free the tline we get passed.
 */
static int
if_condition(Token * tline, int i)
{
    int j, casesense;
    Token *t, *tt, **tptr, *origline;
    struct tokenval tokval;
    nasm_expr *evalresult;

    origline = tline;

    switch (i)
    {
      case PP_IFCTX:
      case PP_ELIFCTX:
      case PP_IFNCTX:
      case PP_ELIFNCTX:
          j = FALSE;          /* have we matched yet? */
          while (cstk && tline)
          {
            skip_white_(tline);
            if (!tline || tline->type != TOK_ID)
            {
                error(ERR_NONFATAL,
                      "`%s' expects context identifiers",
                      directives[i]);
                free_tlist(origline);
                return -1;
            }
            if (!nasm_stricmp(tline->text, cstk->name))
                j = TRUE;
            tline = tline->next;
          }
          if (i == PP_IFNCTX || i == PP_ELIFNCTX)
            j = !j;
          free_tlist(origline);
          return j;

      case PP_IFDEF:
      case PP_ELIFDEF:
      case PP_IFNDEF:
      case PP_ELIFNDEF:
          j = FALSE;          /* have we matched yet? */
          while (tline)
          {
            skip_white_(tline);
            if (!tline || (tline->type != TOK_ID &&
                        (tline->type != TOK_PREPROC_ID ||
                              tline->text[1] != '$')))
            {
                error(ERR_NONFATAL,
                    "`%s' expects macro identifiers",
                    directives[i]);
                free_tlist(origline);
                return -1;
            }
            if (smacro_defined(NULL, tline->text, 0, NULL, 1))
                j = TRUE;
            tline = tline->next;
          }
          if (i == PP_IFNDEF || i == PP_ELIFNDEF)
            j = !j;
          free_tlist(origline);
          return j;

      case PP_IFIDN:
      case PP_ELIFIDN:
      case PP_IFNIDN:
      case PP_ELIFNIDN:
      case PP_IFIDNI:
      case PP_ELIFIDNI:
      case PP_IFNIDNI:
      case PP_ELIFNIDNI:
          tline = expand_smacro(tline);
          t = tt = tline;
          while (tok_isnt_(tt, ","))
            tt = tt->next;
          if (!tt)
          {
            error(ERR_NONFATAL,
                  "`%s' expects two comma-separated arguments",
                  directives[i]);
            free_tlist(tline);
            return -1;
          }
          tt = tt->next;
          casesense = (i == PP_IFIDN || i == PP_ELIFIDN ||
                i == PP_IFNIDN || i == PP_ELIFNIDN);
          j = TRUE;           /* assume equality unless proved not */
          while ((t->type != TOK_OTHER || strcmp(t->text, ",")) && tt)
          {
            if (tt->type == TOK_OTHER && !strcmp(tt->text, ","))
            {
                error(ERR_NONFATAL, "`%s': more than one comma on line",
                      directives[i]);
                free_tlist(tline);
                return -1;
            }
            if (t->type == TOK_WHITESPACE)
            {
                t = t->next;
                continue;
            }
            if (tt->type == TOK_WHITESPACE)
            {
                tt = tt->next;
                continue;
            }
            if (tt->type != t->type)
            {
                j = FALSE;    /* found mismatching tokens */
                break;
            }
            /* Unify surrounding quotes for strings */
            if (t->type == TOK_STRING)
            {
                tt->text[0] = t->text[0];
                tt->text[strlen(tt->text) - 1] = t->text[0];
            }
            if (mstrcmp(tt->text, t->text, casesense) != 0)
            {
                j = FALSE;    /* found mismatching tokens */
                break;
            }

            t = t->next;
            tt = tt->next;
          }
          if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
            j = FALSE;  /* trailing gunk on one end or other */
          if (i == PP_IFNIDN || i == PP_ELIFNIDN ||
                i == PP_IFNIDNI || i == PP_ELIFNIDNI)
            j = !j;
          free_tlist(tline);
          return j;

        case PP_IFMACRO:
        case PP_ELIFMACRO:
        case PP_IFNMACRO:
        case PP_ELIFNMACRO:
      {
          int found = 0;
          MMacro searching, *mmac;

          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tok_type_(tline, TOK_ID))
          {
            error(ERR_NONFATAL,
                  "`%s' expects a macro name",
                  directives[i]);
            return -1;
          }
          searching.name = nasm_strdup(tline->text);
          searching.casesense = (i == PP_MACRO);
          searching.plus = FALSE;
          searching.nolist = FALSE;
          searching.in_progress = FALSE;
          searching.rep_nest = NULL;
          searching.nparam_min = 0;
          searching.nparam_max = INT_MAX;
          tline = expand_smacro(tline->next);
          skip_white_(tline);
          if (!tline)
          {
          } else if (!tok_type_(tline, TOK_NUMBER))
          {
            error(ERR_NONFATAL,
                  "`%s' expects a parameter count or nothing",
                  directives[i]);
          }
          else
          {
            searching.nparam_min = searching.nparam_max =
                  nasm_readnum(tline->text, &j);
            if (j)
                error(ERR_NONFATAL,
                    "unable to parse parameter count `%s'",
                    tline->text);
          }
          if (tline && tok_is_(tline->next, "-"))
          {
            tline = tline->next->next;
            if (tok_is_(tline, "*"))
                searching.nparam_max = INT_MAX;
            else if (!tok_type_(tline, TOK_NUMBER))
                error(ERR_NONFATAL,
                    "`%s' expects a parameter count after `-'",
                    directives[i]);
            else
            {
                searching.nparam_max = nasm_readnum(tline->text, &j);
                if (j)
                  error(ERR_NONFATAL,
                        "unable to parse parameter count `%s'",
                        tline->text);
                if (searching.nparam_min > searching.nparam_max)
                  error(ERR_NONFATAL,
                        "minimum parameter count exceeds maximum");
            }
          }
          if (tline && tok_is_(tline->next, "+"))
          {
            tline = tline->next;
            searching.plus = TRUE;
          }
          mmac = mmacros[hash(searching.name)];
          while (mmac)
          {
            if (!strcmp(mmac->name, searching.name) &&
                  (mmac->nparam_min <= searching.nparam_max
                        || searching.plus)
                  && (searching.nparam_min <= mmac->nparam_max
                        || mmac->plus))
            {
                found = TRUE;
                break;
            }
            mmac = mmac->next;
          }
          nasm_free(searching.name);
          free_tlist(origline);
          if (i == PP_IFNMACRO || i == PP_ELIFNMACRO)
            found = !found;
          return found;
      }

      case PP_IFID:
      case PP_ELIFID:
      case PP_IFNID:
      case PP_ELIFNID:
      case PP_IFNUM:
      case PP_ELIFNUM:
      case PP_IFNNUM:
      case PP_ELIFNNUM:
      case PP_IFSTR:
      case PP_ELIFSTR:
      case PP_IFNSTR:
      case PP_ELIFNSTR:
          tline = expand_smacro(tline);
          t = tline;
          while (tok_type_(t, TOK_WHITESPACE))
            t = t->next;
          j = FALSE;          /* placate optimiser */
          if (t)
            switch (i)
            {
                case PP_IFID:
                case PP_ELIFID:
                case PP_IFNID:
                case PP_ELIFNID:
                  j = (t->type == TOK_ID);
                  break;
                case PP_IFNUM:
                case PP_ELIFNUM:
                case PP_IFNNUM:
                case PP_ELIFNNUM:
                  j = (t->type == TOK_NUMBER);
                  break;
                case PP_IFSTR:
                case PP_ELIFSTR:
                case PP_IFNSTR:
                case PP_ELIFNSTR:
                  j = (t->type == TOK_STRING);
                  break;
            }
          if (i == PP_IFNID || i == PP_ELIFNID ||
                i == PP_IFNNUM || i == PP_ELIFNNUM ||
                i == PP_IFNSTR || i == PP_ELIFNSTR)
            j = !j;
          free_tlist(tline);
          return j;

      case PP_IF:
      case PP_ELIF:
          t = tline = expand_smacro(tline);
          tptr = &t;
          tokval.t_type = TOKEN_INVALID;
          evalresult = evaluate(ppscan, tptr, &tokval,
                NULL, pass | CRITICAL, error, NULL);
          free_tlist(tline);
          if (!evalresult)
            return -1;
          if (tokval.t_type)
            error(ERR_WARNING,
                  "trailing garbage after expression ignored");
          if (!nasm_is_simple(evalresult))
          {
            error(ERR_NONFATAL,
                  "non-constant value given to `%s'", directives[i]);
            return -1;
          }
          return nasm_reloc_value(evalresult) != 0;

      default:
          error(ERR_FATAL,
                "preprocessor directive `%s' not yet implemented",
                directives[i]);
          free_tlist(origline);
          return -1;          /* yeah, right */
    }
}

/*
 * Expand macros in a string. Used in %error and %include directives.
 * First tokenise the string, apply "expand_smacro" and then de-tokenise back.
 * The returned variable should ALWAYS be freed after usage.
 */
static void
expand_macros_in_string(char **p)
{
    Token *line = tokenise(*p);
    line = expand_smacro(line);
    *p = detoken(line, FALSE);
}

/**
 * find and process preprocessor directive in passed line
 * Find out if a line contains a preprocessor directive, and deal
 * with it if so.
 * 
 * If a directive _is_ found, it is the responsibility of this routine
 * (and not the caller) to free_tlist() the line.
 *
 * @param tline a pointer to the current tokeninzed line linked list
 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
 * 
 */
static int
do_directive(Token * tline)
{
    int i, j, k, m, nparam, nolist;
    int offset;
    char *p, *mname;
    Include *inc;
    Context *ctx;
    Cond *cond;
    SMacro *smac, **smhead;
    MMacro *mmac;
    Token *t, *tt, *param_start, *macro_start, *last, **tptr, *origline;
    Line *l;
    struct tokenval tokval;
    nasm_expr *evalresult;
    MMacro *tmp_defining;     /* Used when manipulating rep_nest */

    origline = tline;

    skip_white_(tline);
    if (!tok_type_(tline, TOK_PREPROC_ID) ||
          (tline->text[1] == '%' || tline->text[1] == '$'
                || tline->text[1] == '!'))
      return NO_DIRECTIVE_FOUND;

    i = -1;
    j = elements(directives);
    while (j - i > 1)
    {
      k = (j + i) / 2;
      m = nasm_stricmp(tline->text, directives[k]);
      if (m == 0) {
            if (tasm_compatible_mode) {
            i = k;
            j = -2;
            } else if (k != PP_ARG && k != PP_LOCAL && k != PP_STACKSIZE) {
                i = k;
            j = -2;
            }
          break;
      }
      else if (m < 0) {
          j = k;
      }
      else
          i = k;
    }

    /*
     * If we're in a non-emitting branch of a condition construct,
     * or walking to the end of an already terminated %rep block,
     * we should ignore all directives except for condition
     * directives.
     */
    if (((istk->conds && !emitting(istk->conds->state)) ||
       (istk->mstk && !istk->mstk->in_progress)) &&
      !is_condition(i))
    {
      return NO_DIRECTIVE_FOUND;
    }

    /*
     * If we're defining a macro or reading a %rep block, we should
     * ignore all directives except for %macro/%imacro (which
     * generate an error), %endm/%endmacro, and (only if we're in a
     * %rep block) %endrep. If we're in a %rep block, another %rep
     * causes an error, so should be let through.
     */
    if (defining && i != PP_MACRO && i != PP_IMACRO &&
          i != PP_ENDMACRO && i != PP_ENDM &&
          (defining->name || (i != PP_ENDREP && i != PP_REP)))
    {
      return NO_DIRECTIVE_FOUND;
    }

    if (j != -2)
    {
      error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
            tline->text);
      return NO_DIRECTIVE_FOUND;          /* didn't get it */
    }

    switch (i)
    {
      case PP_STACKSIZE:
          /* Directive to tell NASM what the default stack size is. The
           * default is for a 16-bit stack, and this can be overriden with
           * %stacksize large.
           * the following form:
           *
           *      ARG arg1:WORD, arg2:DWORD, arg4:QWORD
           */
          tline = tline->next;
          if (tline && tline->type == TOK_WHITESPACE)
            tline = tline->next;
          if (!tline || tline->type != TOK_ID)
          {
            error(ERR_NONFATAL, "`%%stacksize' missing size parameter");
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }
          if (nasm_stricmp(tline->text, "flat") == 0)
          {
            /* All subsequent ARG directives are for a 32-bit stack */
            StackSize = 4;
            StackPointer = "ebp";
            ArgOffset = 8;
            LocalOffset = 4;
          }
          else if (nasm_stricmp(tline->text, "large") == 0)
          {
            /* All subsequent ARG directives are for a 16-bit stack,
             * far function call.
             */
            StackSize = 2;
            StackPointer = "bp";
            ArgOffset = 4;
            LocalOffset = 2;
          }
          else if (nasm_stricmp(tline->text, "small") == 0)
          {
            /* All subsequent ARG directives are for a 16-bit stack,
               * far function call. We don't support near functions.
             */
            StackSize = 2;
            StackPointer = "bp";
            ArgOffset = 6;
            LocalOffset = 2;
          }
          else
          {
            error(ERR_NONFATAL, "`%%stacksize' invalid size type");
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_ARG:
          /* TASM like ARG directive to define arguments to functions, in
           * the following form:
           *
           *      ARG arg1:WORD, arg2:DWORD, arg4:QWORD
           */
          offset = ArgOffset;
          do
          {
            char *arg, directive[256];
            int size = StackSize;

            /* Find the argument name */
            tline = tline->next;
            if (tline && tline->type == TOK_WHITESPACE)
                tline = tline->next;
            if (!tline || tline->type != TOK_ID)
            {
                error(ERR_NONFATAL, "`%%arg' missing argument parameter");
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }
            arg = tline->text;

            /* Find the argument size type */
            tline = tline->next;
            if (!tline || tline->type != TOK_OTHER
                  || tline->text[0] != ':')
            {
                error(ERR_NONFATAL,
                      "Syntax error processing `%%arg' directive");
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }
            tline = tline->next;
            if (!tline || tline->type != TOK_ID)
            {
                error(ERR_NONFATAL,
                      "`%%arg' missing size type parameter");
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }

            /* Allow macro expansion of type parameter */
            tt = tokenise(tline->text);
            tt = expand_smacro(tt);
            if (nasm_stricmp(tt->text, "byte") == 0)
            {
                size = MAX(StackSize, 1);
            }
            else if (nasm_stricmp(tt->text, "word") == 0)
            {
                size = MAX(StackSize, 2);
            }
            else if (nasm_stricmp(tt->text, "dword") == 0)
            {
                size = MAX(StackSize, 4);
            }
            else if (nasm_stricmp(tt->text, "qword") == 0)
            {
                size = MAX(StackSize, 8);
            }
            else if (nasm_stricmp(tt->text, "tword") == 0)
            {
                size = MAX(StackSize, 10);
            }
            else
            {
                error(ERR_NONFATAL,
                      "Invalid size type for `%%arg' missing directive");
                free_tlist(tt);
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }
            free_tlist(tt);

            /* Now define the macro for the argument */
            sprintf(directive, "%%define %s (%s+%d)", arg, StackPointer,
                  offset);
            do_directive(tokenise(directive));
            offset += size;

            /* Move to the next argument in the list */
            tline = tline->next;
            if (tline && tline->type == TOK_WHITESPACE)
                tline = tline->next;
          }
          while (tline && tline->type == TOK_OTHER
                && tline->text[0] == ',');
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_LOCAL:
          /* TASM like LOCAL directive to define local variables for a
           * function, in the following form:
           *
           *      LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
           *
           * The '= LocalSize' at the end is ignored by NASM, but is
           * required by TASM to define the local parameter size (and used
           * by the TASM macro package).
           */
          offset = LocalOffset;
          do
          {
            char *local, directive[256];
            int size = StackSize;

            /* Find the argument name */
            tline = tline->next;
            if (tline && tline->type == TOK_WHITESPACE)
                tline = tline->next;
            if (!tline || tline->type != TOK_ID)
            {
                error(ERR_NONFATAL,
                      "`%%local' missing argument parameter");
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }
            local = tline->text;

            /* Find the argument size type */
            tline = tline->next;
            if (!tline || tline->type != TOK_OTHER
                  || tline->text[0] != ':')
            {
                error(ERR_NONFATAL,
                      "Syntax error processing `%%local' directive");
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }
            tline = tline->next;
            if (!tline || tline->type != TOK_ID)
            {
                error(ERR_NONFATAL,
                      "`%%local' missing size type parameter");
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }

            /* Allow macro expansion of type parameter */
            tt = tokenise(tline->text);
            tt = expand_smacro(tt);
            if (nasm_stricmp(tt->text, "byte") == 0)
            {
                size = MAX(StackSize, 1);
            }
            else if (nasm_stricmp(tt->text, "word") == 0)
            {
                size = MAX(StackSize, 2);
            }
            else if (nasm_stricmp(tt->text, "dword") == 0)
            {
                size = MAX(StackSize, 4);
            }
            else if (nasm_stricmp(tt->text, "qword") == 0)
            {
                size = MAX(StackSize, 8);
            }
            else if (nasm_stricmp(tt->text, "tword") == 0)
            {
                size = MAX(StackSize, 10);
            }
            else
            {
                error(ERR_NONFATAL,
                      "Invalid size type for `%%local' missing directive");
                free_tlist(tt);
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }
            free_tlist(tt);

            /* Now define the macro for the argument */
            sprintf(directive, "%%define %s (%s-%d)", local, StackPointer,
                  offset);
            do_directive(tokenise(directive));
            offset += size;

            /* Now define the assign to setup the enter_c macro correctly */
            sprintf(directive, "%%assign %%$localsize %%$localsize+%d",
                  size);
            do_directive(tokenise(directive));

            /* Move to the next argument in the list */
            tline = tline->next;
            if (tline && tline->type == TOK_WHITESPACE)
                tline = tline->next;
          }
          while (tline && tline->type == TOK_OTHER
                && tline->text[0] == ',');
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_CLEAR:
          if (tline->next)
            error(ERR_WARNING,
                  "trailing garbage after `%%clear' ignored");
          for (j = 0; j < NHASH; j++)
          {
            while (mmacros[j])
            {
                MMacro *m2 = mmacros[j];
                mmacros[j] = m2->next;
                free_mmacro(m2);
            }
            while (smacros[j])
            {
                SMacro *s = smacros[j];
                smacros[j] = smacros[j]->next;
                nasm_free(s->name);
                free_tlist(s->expansion);
                nasm_free(s);
            }
          }
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_INCLUDE:
          tline = tline->next;
          skip_white_(tline);
          if (!tline || (tline->type != TOK_STRING &&
                      tline->type != TOK_INTERNAL_STRING))
          {
            error(ERR_NONFATAL, "`%%include' expects a file name");
            free_tlist(origline);
            return DIRECTIVE_FOUND; /* but we did _something_ */
          }
          if (tline->next)
            error(ERR_WARNING,
                  "trailing garbage after `%%include' ignored");
          if (tline->type != TOK_INTERNAL_STRING)
          {
            p = tline->text + 1;    /* point past the quote to the name */
            p[strlen(p) - 1] = '\0';      /* remove the trailing quote */
          }
          else
            p = tline->text;  /* internal_string is easier */
          expand_macros_in_string(&p);
          inc = nasm_malloc(sizeof(Include));
          inc->next = istk;
          inc->conds = NULL;
          inc->fp = inc_fopen(p);
          inc->fname = nasm_src_set_fname(p);
          inc->lineno = nasm_src_set_linnum(0);
          inc->lineinc = 1;
          inc->expansion = NULL;
          inc->mstk = NULL;
          istk = inc;
          list->uplevel(LIST_INCLUDE);
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_PUSH:
          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tok_type_(tline, TOK_ID))
          {
            error(ERR_NONFATAL, "`%%push' expects a context identifier");
            free_tlist(origline);
            return DIRECTIVE_FOUND; /* but we did _something_ */
          }
          if (tline->next)
            error(ERR_WARNING, "trailing garbage after `%%push' ignored");
          ctx = nasm_malloc(sizeof(Context));
          ctx->next = cstk;
          ctx->localmac = NULL;
          ctx->name = nasm_strdup(tline->text);
          ctx->number = unique++;
          cstk = ctx;
          free_tlist(origline);
          break;

      case PP_REPL:
          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tok_type_(tline, TOK_ID))
          {
            error(ERR_NONFATAL, "`%%repl' expects a context identifier");
            free_tlist(origline);
            return DIRECTIVE_FOUND; /* but we did _something_ */
          }
          if (tline->next)
            error(ERR_WARNING, "trailing garbage after `%%repl' ignored");
          if (!cstk)
            error(ERR_NONFATAL, "`%%repl': context stack is empty");
          else
          {
            nasm_free(cstk->name);
            cstk->name = nasm_strdup(tline->text);
          }
          free_tlist(origline);
          break;

      case PP_POP:
          if (tline->next)
            error(ERR_WARNING, "trailing garbage after `%%pop' ignored");
          if (!cstk)
            error(ERR_NONFATAL,
                  "`%%pop': context stack is already empty");
          else
            ctx_pop();
          free_tlist(origline);
          break;

      case PP_ERROR:
          tline->next = expand_smacro(tline->next);
          tline = tline->next;
          skip_white_(tline);
          if (tok_type_(tline, TOK_STRING))
          {
            p = tline->text + 1;    /* point past the quote to the name */
            p[strlen(p) - 1] = '\0';      /* remove the trailing quote */
            expand_macros_in_string(&p);
            error(ERR_NONFATAL, "%s", p);
            nasm_free(p);
          }
          else
          {
            p = detoken(tline, FALSE);
            error(ERR_WARNING, "%s", p);
            nasm_free(p);
          }
          free_tlist(origline);
          break;

      case PP_IF:
      case PP_IFCTX:
      case PP_IFDEF:
      case PP_IFID:
      case PP_IFIDN:
      case PP_IFIDNI:
        case PP_IFMACRO:
      case PP_IFNCTX:
      case PP_IFNDEF:
      case PP_IFNID:
      case PP_IFNIDN:
      case PP_IFNIDNI:
        case PP_IFNMACRO:
      case PP_IFNNUM:
      case PP_IFNSTR:
      case PP_IFNUM:
      case PP_IFSTR:
          if (istk->conds && !emitting(istk->conds->state))
            j = COND_NEVER;
          else
          {
            j = if_condition(tline->next, i);
            tline->next = NULL;     /* it got freed */
            free_tlist(origline);
            j = j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
          }
          cond = nasm_malloc(sizeof(Cond));
          cond->next = istk->conds;
          cond->state = j;
          istk->conds = cond;
          return DIRECTIVE_FOUND;

      case PP_ELIF:
      case PP_ELIFCTX:
      case PP_ELIFDEF:
      case PP_ELIFID:
      case PP_ELIFIDN:
      case PP_ELIFIDNI:
        case PP_ELIFMACRO:
      case PP_ELIFNCTX:
      case PP_ELIFNDEF:
      case PP_ELIFNID:
      case PP_ELIFNIDN:
      case PP_ELIFNIDNI:
        case PP_ELIFNMACRO:
      case PP_ELIFNNUM:
      case PP_ELIFNSTR:
      case PP_ELIFNUM:
      case PP_ELIFSTR:
          if (!istk->conds)
            error(ERR_FATAL, "`%s': no matching `%%if'", directives[i]);
          if (emitting(istk->conds->state)
                || istk->conds->state == COND_NEVER)
            istk->conds->state = COND_NEVER;
          else
          {
            /*
             * IMPORTANT: In the case of %if, we will already have
             * called expand_mmac_params(); however, if we're
             * processing an %elif we must have been in a
             * non-emitting mode, which would have inhibited
             * the normal invocation of expand_mmac_params().  Therefore,
             * we have to do it explicitly here.
             */
             j = if_condition(expand_mmac_params(tline->next), i);
             tline->next = NULL; /* it got freed */
            free_tlist(origline);
            istk->conds->state =
                  j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
          }
          return DIRECTIVE_FOUND;

      case PP_ELSE:
          if (tline->next)
            error(ERR_WARNING, "trailing garbage after `%%else' ignored");
          if (!istk->conds)
            error(ERR_FATAL, "`%%else': no matching `%%if'");
          if (emitting(istk->conds->state)
                || istk->conds->state == COND_NEVER)
            istk->conds->state = COND_ELSE_FALSE;
          else
            istk->conds->state = COND_ELSE_TRUE;
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_ENDIF:
          if (tline->next)
            error(ERR_WARNING,
                  "trailing garbage after `%%endif' ignored");
          if (!istk->conds)
            error(ERR_FATAL, "`%%endif': no matching `%%if'");
          cond = istk->conds;
          istk->conds = cond->next;
          nasm_free(cond);
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_MACRO:
      case PP_IMACRO:
          if (defining)
            error(ERR_FATAL,
                  "`%%%smacro': already defining a macro",
                  (i == PP_IMACRO ? "i" : ""));
          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tok_type_(tline, TOK_ID))
          {
            error(ERR_NONFATAL,
                  "`%%%smacro' expects a macro name",
                  (i == PP_IMACRO ? "i" : ""));
            return DIRECTIVE_FOUND;
          }
          defining = nasm_malloc(sizeof(MMacro));
          defining->name = nasm_strdup(tline->text);
          defining->casesense = (i == PP_MACRO);
          defining->plus = FALSE;
          defining->nolist = FALSE;
          defining->in_progress = FALSE;
          defining->rep_nest = NULL;
          tline = expand_smacro(tline->next);
          skip_white_(tline);
          if (!tok_type_(tline, TOK_NUMBER))
          {
            error(ERR_NONFATAL,
                  "`%%%smacro' expects a parameter count",
                  (i == PP_IMACRO ? "i" : ""));
            defining->nparam_min = defining->nparam_max = 0;
          }
          else
          {
            defining->nparam_min = defining->nparam_max =
                  nasm_readnum(tline->text, &j);
            if (j)
                error(ERR_NONFATAL,
                      "unable to parse parameter count `%s'",
                      tline->text);
          }
          if (tline && tok_is_(tline->next, "-"))
          {
            tline = tline->next->next;
            if (tok_is_(tline, "*"))
                defining->nparam_max = INT_MAX;
            else if (!tok_type_(tline, TOK_NUMBER))
                error(ERR_NONFATAL,
                      "`%%%smacro' expects a parameter count after `-'",
                      (i == PP_IMACRO ? "i" : ""));
            else
            {
                defining->nparam_max = nasm_readnum(tline->text, &j);
                if (j)
                  error(ERR_NONFATAL,
                        "unable to parse parameter count `%s'",
                        tline->text);
                if (defining->nparam_min > defining->nparam_max)
                  error(ERR_NONFATAL,
                        "minimum parameter count exceeds maximum");
            }
          }
          if (tline && tok_is_(tline->next, "+"))
          {
            tline = tline->next;
            defining->plus = TRUE;
          }
          if (tline && tok_type_(tline->next, TOK_ID) &&
                !nasm_stricmp(tline->next->text, ".nolist"))
          {
            tline = tline->next;
            defining->nolist = TRUE;
          }
          mmac = mmacros[hash(defining->name)];
          while (mmac)
          {
            if (!strcmp(mmac->name, defining->name) &&
                  (mmac->nparam_min <= defining->nparam_max
                        || defining->plus)
                  && (defining->nparam_min <= mmac->nparam_max
                        || mmac->plus))
            {
                error(ERR_WARNING,
                      "redefining multi-line macro `%s'",
                      defining->name);
                break;
            }
            mmac = mmac->next;
          }
          /*
           * Handle default parameters.
           */
          if (tline && tline->next)
          {
            defining->dlist = tline->next;
            tline->next = NULL;
            count_mmac_params(defining->dlist, &defining->ndefs,
                  &defining->defaults);
          }
          else
          {
            defining->dlist = NULL;
            defining->defaults = NULL;
          }
          defining->expansion = NULL;
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_ENDM:
      case PP_ENDMACRO:
          if (!defining)
          {
            error(ERR_NONFATAL, "`%s': not defining a macro",
                  tline->text);
            return DIRECTIVE_FOUND;
          }
          k = hash(defining->name);
          defining->next = mmacros[k];
          mmacros[k] = defining;
          defining = NULL;
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_ROTATE:
          if (tline->next && tline->next->type == TOK_WHITESPACE)
            tline = tline->next;
          if (tline->next == NULL)
          {
            free_tlist(origline);
            error(ERR_NONFATAL, "`%%rotate' missing rotate count");
            return DIRECTIVE_FOUND;
          }
          t = expand_smacro(tline->next);
          tline->next = NULL;
          free_tlist(origline);
          tline = t;
          tptr = &t;
          tokval.t_type = TOKEN_INVALID;
          evalresult =
                evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
          free_tlist(tline);
          if (!evalresult)
            return DIRECTIVE_FOUND;
          if (tokval.t_type)
            error(ERR_WARNING,
                  "trailing garbage after expression ignored");
          if (!nasm_is_simple(evalresult))
          {
            error(ERR_NONFATAL, "non-constant value given to `%%rotate'");
            return DIRECTIVE_FOUND;
          }
          mmac = istk->mstk;
          while (mmac && !mmac->name)     /* avoid mistaking %reps for macros */
            mmac = mmac->next_active;
          if (!mmac)
          {
            error(ERR_NONFATAL,
                  "`%%rotate' invoked outside a macro call");
          } 
          else if (mmac->nparam == 0)
          {
            error(ERR_NONFATAL,
                  "`%%rotate' invoked within macro without parameters");
          }
          else
          {
            mmac->rotate = mmac->rotate + nasm_reloc_value(evalresult);
            
            if (mmac->rotate < 0)
                mmac->rotate = 
                  mmac->nparam - (-mmac->rotate) % mmac->nparam;
            mmac->rotate %= mmac->nparam;
          }
          return DIRECTIVE_FOUND;

      case PP_REP:
          nolist = FALSE;
          do {
            tline = tline->next;
          } while (tok_type_(tline, TOK_WHITESPACE));

          if (tok_type_(tline, TOK_ID) &&
            nasm_stricmp(tline->text, ".nolist") == 0)
          {
            nolist = TRUE;
            do {
                tline = tline->next;
            } while (tok_type_(tline, TOK_WHITESPACE));
          }

          if (tline)
          {
            t = expand_smacro(tline);
            tptr = &t;
            tokval.t_type = TOKEN_INVALID;
            evalresult =
                evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
            if (!evalresult)
            {
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }
            if (tokval.t_type)
                error(ERR_WARNING,
                    "trailing garbage after expression ignored");
            if (!nasm_is_simple(evalresult))
            {
                error(ERR_NONFATAL, "non-constant value given to `%%rep'");
                return DIRECTIVE_FOUND;
            }
            i = (int)nasm_reloc_value(evalresult) + 1;
          }
          else
          {
            error(ERR_NONFATAL, "`%%rep' expects a repeat count");
            i = 0;
          }
          free_tlist(origline);

          tmp_defining = defining;
          defining = nasm_malloc(sizeof(MMacro));
          defining->name = NULL;    /* flags this macro as a %rep block */
          defining->casesense = 0;
          defining->plus = FALSE;
          defining->nolist = nolist;
          defining->in_progress = i;
          defining->nparam_min = defining->nparam_max = 0;
          defining->defaults = NULL;
          defining->dlist = NULL;
          defining->expansion = NULL;
          defining->next_active = istk->mstk;
          defining->rep_nest = tmp_defining;
          return DIRECTIVE_FOUND;

      case PP_ENDREP:
          if (!defining || defining->name)
          {
            error(ERR_NONFATAL, "`%%endrep': no matching `%%rep'");
            return DIRECTIVE_FOUND;
          }

          /*
           * Now we have a "macro" defined - although it has no name
           * and we won't be entering it in the hash tables - we must
           * push a macro-end marker for it on to istk->expansion.
           * After that, it will take care of propagating itself (a
           * macro-end marker line for a macro which is really a %rep
           * block will cause the macro to be re-expanded, complete
           * with another macro-end marker to ensure the process
           * continues) until the whole expansion is forcibly removed
           * from istk->expansion by a %exitrep.
           */
          l = nasm_malloc(sizeof(Line));
          l->next = istk->expansion;
          l->finishes = defining;
          l->first = NULL;
          istk->expansion = l;

          istk->mstk = defining;

          list->uplevel(defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
          tmp_defining = defining;
          defining = defining->rep_nest;
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_EXITREP:
          /*
           * We must search along istk->expansion until we hit a
           * macro-end marker for a macro with no name. Then we set
           * its `in_progress' flag to 0.
           */
          for (l = istk->expansion; l; l = l->next)
            if (l->finishes && !l->finishes->name)
                break;

          if (l)
            l->finishes->in_progress = 0;
          else
            error(ERR_NONFATAL, "`%%exitrep' not within `%%rep' block");
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_XDEFINE:
      case PP_IXDEFINE:
      case PP_DEFINE:
      case PP_IDEFINE:
          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tline || (tline->type != TOK_ID &&
                      (tline->type != TOK_PREPROC_ID ||
                            tline->text[1] != '$')))
          {
            error(ERR_NONFATAL,
                  "`%%%s%sdefine' expects a macro identifier",
                  ((i == PP_IDEFINE || i == PP_IXDEFINE) ? "i" : ""),
                  ((i == PP_XDEFINE || i == PP_IXDEFINE) ? "x" : ""));
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }

          ctx = get_ctx(tline->text, FALSE);
          if (!ctx)
            smhead = &smacros[hash(tline->text)];
          else
            smhead = &ctx->localmac;
          mname = tline->text;
          last = tline;
          param_start = tline = tline->next;
          nparam = 0;

          /* Expand the macro definition now for %xdefine and %ixdefine */
          if ((i == PP_XDEFINE) || (i == PP_IXDEFINE))
            tline = expand_smacro(tline);

          if (tok_is_(tline, "("))
          {
            /*
             * This macro has parameters.
             */

            tline = tline->next;
            while (1)
            {
                skip_white_(tline);
                if (!tline)
                {
                  error(ERR_NONFATAL, "parameter identifier expected");
                  free_tlist(origline);
                  return DIRECTIVE_FOUND;
                }
                if (tline->type != TOK_ID)
                {
                  error(ERR_NONFATAL,
                        "`%s': parameter identifier expected",
                        tline->text);
                  free_tlist(origline);
                  return DIRECTIVE_FOUND;
                }
                tline->type = TOK_SMAC_PARAM + nparam++;
                tline = tline->next;
                skip_white_(tline);
                if (tok_is_(tline, ","))
                {
                  tline = tline->next;
                  continue;
                }
                if (!tok_is_(tline, ")"))
                {
                  error(ERR_NONFATAL,
                        "`)' expected to terminate macro template");
                  free_tlist(origline);
                  return DIRECTIVE_FOUND;
                }
                break;
            }
            last = tline;
            tline = tline->next;
          }
          if (tok_type_(tline, TOK_WHITESPACE))
            last = tline, tline = tline->next;
          macro_start = NULL;
          last->next = NULL;
          t = tline;
          while (t)
          {
            if (t->type == TOK_ID)
            {
                for (tt = param_start; tt; tt = tt->next)
                  if (tt->type >= TOK_SMAC_PARAM &&
                        !strcmp(tt->text, t->text))
                      t->type = tt->type;
            }
            tt = t->next;
            t->next = macro_start;
            macro_start = t;
            t = tt;
          }
          /*
           * Good. We now have a macro name, a parameter count, and a
           * token list (in reverse order) for an expansion. We ought
           * to be OK just to create an SMacro, store it, and let
           * free_tlist have the rest of the line (which we have
           * carefully re-terminated after chopping off the expansion
           * from the end).
           */
          if (smacro_defined(ctx, mname, nparam, &smac, i == PP_DEFINE))
          {
            if (!smac)
            {
                error(ERR_WARNING,
                      "single-line macro `%s' defined both with and"
                      " without parameters", mname);
                free_tlist(origline);
                free_tlist(macro_start);
                return DIRECTIVE_FOUND;
            }
            else
            {
                /*
                 * We're redefining, so we have to take over an
                 * existing SMacro structure. This means freeing
                 * what was already in it.
                 */
                nasm_free(smac->name);
                free_tlist(smac->expansion);
            }
          }
          else
          {
            smac = nasm_malloc(sizeof(SMacro));
            smac->next = *smhead;
            *smhead = smac;
          }
          smac->name = nasm_strdup(mname);
          smac->casesense = ((i == PP_DEFINE) || (i == PP_XDEFINE));
          smac->nparam = nparam;
          smac->expansion = macro_start;
          smac->in_progress = FALSE;
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_UNDEF:
          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tline || (tline->type != TOK_ID &&
                      (tline->type != TOK_PREPROC_ID ||
                            tline->text[1] != '$')))
          {
            error(ERR_NONFATAL, "`%%undef' expects a macro identifier");
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }
          if (tline->next)
          {
            error(ERR_WARNING,
                  "trailing garbage after macro name ignored");
          }

          /* Find the context that symbol belongs to */
          ctx = get_ctx(tline->text, FALSE);
          if (!ctx)
            smhead = &smacros[hash(tline->text)];
          else
            smhead = &ctx->localmac;

          mname = tline->text;
          last = tline;
          last->next = NULL;

          /*
           * We now have a macro name... go hunt for it.
           */
          while (smacro_defined(ctx, mname, -1, &smac, 1))
          {
            /* Defined, so we need to find its predecessor and nuke it */
            SMacro **s;
            for (s = smhead; *s && *s != smac; s = &(*s)->next);
            if (*s)
            {
                *s = smac->next;
                nasm_free(smac->name);
                free_tlist(smac->expansion);
                nasm_free(smac);
            }
          }
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_STRLEN:
          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tline || (tline->type != TOK_ID &&
                      (tline->type != TOK_PREPROC_ID ||
                            tline->text[1] != '$')))
          {
            error(ERR_NONFATAL,
                  "`%%strlen' expects a macro identifier as first parameter");
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }
          ctx = get_ctx(tline->text, FALSE);
          if (!ctx)
            smhead = &smacros[hash(tline->text)];
          else
            smhead = &ctx->localmac;
          mname = tline->text;
          last = tline;
          tline = expand_smacro(tline->next);
          last->next = NULL;

          t = tline;
          while (tok_type_(t, TOK_WHITESPACE))
            t = t->next;
          /* t should now point to the string */
          if (t->type != TOK_STRING)
          {
            error(ERR_NONFATAL,
                  "`%%strlen` requires string as second parameter");
            free_tlist(tline);
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }

          macro_start = nasm_malloc(sizeof(*macro_start));
          macro_start->next = NULL;
          make_tok_num(macro_start, (int)strlen(t->text) - 2);
          macro_start->mac = NULL;

          /*
           * We now have a macro name, an implicit parameter count of
           * zero, and a numeric token to use as an expansion. Create
           * and store an SMacro.
           */
          if (smacro_defined(ctx, mname, 0, &smac, i == PP_STRLEN))
          {
            if (!smac)
                error(ERR_WARNING,
                      "single-line macro `%s' defined both with and"
                      " without parameters", mname);
            else
            {
                /*
                 * We're redefining, so we have to take over an
                 * existing SMacro structure. This means freeing
                 * what was already in it.
                 */
                nasm_free(smac->name);
                free_tlist(smac->expansion);
            }
          }
          else
          {
            smac = nasm_malloc(sizeof(SMacro));
            smac->next = *smhead;
            *smhead = smac;
          }
          smac->name = nasm_strdup(mname);
          smac->casesense = (i == PP_STRLEN);
          smac->nparam = 0;
          smac->expansion = macro_start;
          smac->in_progress = FALSE;
          free_tlist(tline);
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_SUBSTR:
          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tline || (tline->type != TOK_ID &&
                      (tline->type != TOK_PREPROC_ID ||
                            tline->text[1] != '$')))
          {
            error(ERR_NONFATAL,
                  "`%%substr' expects a macro identifier as first parameter");
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }
          ctx = get_ctx(tline->text, FALSE);
          if (!ctx)
            smhead = &smacros[hash(tline->text)];
          else
            smhead = &ctx->localmac;
          mname = tline->text;
          last = tline;
          tline = expand_smacro(tline->next);
          last->next = NULL;

          t = tline->next;
          while (tok_type_(t, TOK_WHITESPACE))
            t = t->next;

          /* t should now point to the string */
          if (t->type != TOK_STRING)
          {
            error(ERR_NONFATAL,
                  "`%%substr` requires string as second parameter");
            free_tlist(tline);
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }

          tt = t->next;
          tptr = &tt;
          tokval.t_type = TOKEN_INVALID;
          evalresult =
                evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
          if (!evalresult)
          {
            free_tlist(tline);
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }
          if (!nasm_is_simple(evalresult))
          {
            error(ERR_NONFATAL, "non-constant value given to `%%substr`");
            free_tlist(tline);
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }

          macro_start = nasm_malloc(sizeof(*macro_start));
          macro_start->next = NULL;
          macro_start->text = nasm_strdup("'''");
          if (evalresult->value > 0
                && evalresult->value < (int)strlen(t->text) - 1)
          {
            macro_start->text[1] = t->text[evalresult->value];
          }
          else
          {
            macro_start->text[2] = '\0';
          }
          macro_start->type = TOK_STRING;
          macro_start->mac = NULL;

          /*
           * We now have a macro name, an implicit parameter count of
           * zero, and a numeric token to use as an expansion. Create
           * and store an SMacro.
           */
          if (smacro_defined(ctx, mname, 0, &smac, i == PP_SUBSTR))
          {
            if (!smac)
                error(ERR_WARNING,
                      "single-line macro `%s' defined both with and"
                      " without parameters", mname);
            else
            {
                /*
                 * We're redefining, so we have to take over an
                 * existing SMacro structure. This means freeing
                 * what was already in it.
                 */
                nasm_free(smac->name);
                free_tlist(smac->expansion);
            }
          }
          else
          {
            smac = nasm_malloc(sizeof(SMacro));
            smac->next = *smhead;
            *smhead = smac;
          }
          smac->name = nasm_strdup(mname);
          smac->casesense = (i == PP_SUBSTR);
          smac->nparam = 0;
          smac->expansion = macro_start;
          smac->in_progress = FALSE;
          free_tlist(tline);
          free_tlist(origline);
          return DIRECTIVE_FOUND;


      case PP_ASSIGN:
      case PP_IASSIGN:
          tline = tline->next;
          skip_white_(tline);
          tline = expand_id(tline);
          if (!tline || (tline->type != TOK_ID &&
                      (tline->type != TOK_PREPROC_ID ||
                            tline->text[1] != '$')))
          {
            error(ERR_NONFATAL,
                  "`%%%sassign' expects a macro identifier",
                  (i == PP_IASSIGN ? "i" : ""));
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }
          ctx = get_ctx(tline->text, FALSE);
          if (!ctx)
            smhead = &smacros[hash(tline->text)];
          else
            smhead = &ctx->localmac;
          mname = tline->text;
          last = tline;
          tline = expand_smacro(tline->next);
          last->next = NULL;

          t = tline;
          tptr = &t;
          tokval.t_type = TOKEN_INVALID;
          evalresult =
                evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
          free_tlist(tline);
          if (!evalresult)
          {
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }

          if (tokval.t_type)
            error(ERR_WARNING,
                  "trailing garbage after expression ignored");

          if (!nasm_is_simple(evalresult))
          {
            error(ERR_NONFATAL,
                  "non-constant value given to `%%%sassign'",
                  (i == PP_IASSIGN ? "i" : ""));
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }

          macro_start = nasm_malloc(sizeof(*macro_start));
          macro_start->next = NULL;
          make_tok_num(macro_start, nasm_reloc_value(evalresult));
          macro_start->mac = NULL;

          /*
           * We now have a macro name, an implicit parameter count of
           * zero, and a numeric token to use as an expansion. Create
           * and store an SMacro.
           */
          if (smacro_defined(ctx, mname, 0, &smac, i == PP_ASSIGN))
          {
            if (!smac)
                error(ERR_WARNING,
                      "single-line macro `%s' defined both with and"
                      " without parameters", mname);
            else
            {
                /*
                 * We're redefining, so we have to take over an
                 * existing SMacro structure. This means freeing
                 * what was already in it.
                 */
                nasm_free(smac->name);
                free_tlist(smac->expansion);
            }
          }
          else
          {
            smac = nasm_malloc(sizeof(SMacro));
            smac->next = *smhead;
            *smhead = smac;
          }
          smac->name = nasm_strdup(mname);
          smac->casesense = (i == PP_ASSIGN);
          smac->nparam = 0;
          smac->expansion = macro_start;
          smac->in_progress = FALSE;
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      case PP_LINE:
          /*
           * Syntax is `%line nnn[+mmm] [filename]'
           */
          tline = tline->next;
          skip_white_(tline);
          if (!tok_type_(tline, TOK_NUMBER))
          {
            error(ERR_NONFATAL, "`%%line' expects line number");
            free_tlist(origline);
            return DIRECTIVE_FOUND;
          }
          k = nasm_readnum(tline->text, &j);
          m = 1;
          tline = tline->next;
          if (tok_is_(tline, "+"))
          {
            tline = tline->next;
            if (!tok_type_(tline, TOK_NUMBER))
            {
                error(ERR_NONFATAL, "`%%line' expects line increment");
                free_tlist(origline);
                return DIRECTIVE_FOUND;
            }
            m = nasm_readnum(tline->text, &j);
            tline = tline->next;
          }
          skip_white_(tline);
          nasm_src_set_linnum(k);
          istk->lineinc = m;
          if (tline)
          {
            nasm_free(nasm_src_set_fname(detoken(tline, FALSE)));
          }
          free_tlist(origline);
          return DIRECTIVE_FOUND;

      default:
          error(ERR_FATAL,
                "preprocessor directive `%s' not yet implemented",
                directives[i]);
          break;
    }
    return DIRECTIVE_FOUND;
}

/*
 * Ensure that a macro parameter contains a condition code and
 * nothing else. Return the condition code index if so, or -1
 * otherwise.
 */
static int
find_cc(Token * t)
{
    Token *tt;
    int i, j, k, m;

    skip_white_(t);
    if (t->type != TOK_ID)
      return -1;
    tt = t->next;
    skip_white_(tt);
    if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
      return -1;

    i = -1;
    j = elements(conditions);
    while (j - i > 1)
    {
      k = (j + i) / 2;
      m = nasm_stricmp(t->text, conditions[k]);
      if (m == 0)
      {
          i = k;
          j = -2;
          break;
      }
      else if (m < 0)
      {
          j = k;
      }
      else
          i = k;
    }
    if (j != -2)
      return -1;
    return i;
}

/*
 * Expand MMacro-local things: parameter references (%0, %n, %+n,
 * %-n) and MMacro-local identifiers (%%foo).
 */
static Token *
expand_mmac_params(Token * tline)
{
    Token *t, *tt, **tail, *thead;

    tail = &thead;
    thead = NULL;

    while (tline)
    {
      if (tline->type == TOK_PREPROC_ID &&
            (((tline->text[1] == '+' || tline->text[1] == '-')
                        && tline->text[2]) || tline->text[1] == '%'
                  || (tline->text[1] >= '0' && tline->text[1] <= '9')))
      {
          char *text = NULL;
          int type = 0, cc;   /* type = 0 to placate optimisers */
          char tmpbuf[30];
          int n, i;
          MMacro *mac;

          t = tline;
          tline = tline->next;

          mac = istk->mstk;
          while (mac && !mac->name) /* avoid mistaking %reps for macros */
            mac = mac->next_active;
          if (!mac)
            error(ERR_NONFATAL, "`%s': not in a macro call", t->text);
          else
            switch (t->text[1])
            {
                  /*
                   * We have to make a substitution of one of the
                   * forms %1, %-1, %+1, %%foo, %0.
                   */
                case '0':
                  type = TOK_NUMBER;
                  sprintf(tmpbuf, "%d", mac->nparam);
                  text = nasm_strdup(tmpbuf);
                  break;
                case '%':
                  type = TOK_ID;
                  sprintf(tmpbuf, "..@%lu.", mac->unique);
                  text = nasm_strcat(tmpbuf, t->text + 2);
                  break;
                case '-':
                  n = atoi(t->text + 2) - 1;
                  if (n >= mac->nparam)
                      tt = NULL;
                  else
                  {
                      if (mac->nparam > 1)
                        n = (n + mac->rotate) % mac->nparam;
                      tt = mac->params[n];
                  }
                  cc = find_cc(tt);
                  if (cc == -1)
                  {
                      error(ERR_NONFATAL,
                            "macro parameter %d is not a condition code",
                            n + 1);
                      text = NULL;
                  }
                  else
                  {
                      type = TOK_ID;
                      if (inverse_ccs[cc] == -1)
                      {
                        error(ERR_NONFATAL,
                              "condition code `%s' is not invertible",
                              conditions[cc]);
                        text = NULL;
                      }
                      else
                        text =
                              nasm_strdup(conditions[inverse_ccs
                                     [cc]]);
                  }
                  break;
                case '+':
                  n = atoi(t->text + 2) - 1;
                  if (n >= mac->nparam)
                      tt = NULL;
                  else
                  {
                      if (mac->nparam > 1)
                        n = (n + mac->rotate) % mac->nparam;
                      tt = mac->params[n];
                  }
                  cc = find_cc(tt);
                  if (cc == -1)
                  {
                      error(ERR_NONFATAL,
                            "macro parameter %d is not a condition code",
                            n + 1);
                      text = NULL;
                  }
                  else
                  {
                      type = TOK_ID;
                      text = nasm_strdup(conditions[cc]);
                  }
                  break;
                default:
                  n = atoi(t->text + 1) - 1;
                  if (n >= mac->nparam)
                      tt = NULL;
                  else
                  {
                      if (mac->nparam > 1)
                        n = (n + mac->rotate) % mac->nparam;
                      tt = mac->params[n];
                  }
                  if (tt)
                  {
                      for (i = 0; i < mac->paramlen[n]; i++)
                      {
                        *tail =
                              new_Token(NULL, tt->type, tt->text,
                              0);
                        tail = &(*tail)->next;
                        tt = tt->next;
                      }
                  }
                  text = NULL;      /* we've done it here */
                  break;
            }
          if (!text)
          {
            delete_Token(t);
          }
          else
          {
            *tail = t;
            tail = &t->next;
            t->type = type;
            nasm_free(t->text);
            t->text = text;
            t->mac = NULL;
          }
          continue;
      }
      else
      {
          t = *tail = tline;
          tline = tline->next;
          t->mac = NULL;
          tail = &t->next;
      }
    }
    *tail = NULL;
    t = thead;
    for (; t && (tt = t->next) != NULL; t = t->next)
      switch (t->type)
      {
          case TOK_WHITESPACE:
            if (tt->type == TOK_WHITESPACE)
            {
                t->next = delete_Token(tt);
            }
            break;
          case TOK_ID:
            if (tt->type == TOK_ID || tt->type == TOK_NUMBER)
            {
                char *tmp = nasm_strcat(t->text, tt->text);
                nasm_free(t->text);
                t->text = tmp;
                t->next = delete_Token(tt);
            }
            break;
          case TOK_NUMBER:
            if (tt->type == TOK_NUMBER)
            {
                char *tmp = nasm_strcat(t->text, tt->text);
                nasm_free(t->text);
                t->text = tmp;
                t->next = delete_Token(tt);
            }
            break;
      }

    return thead;
}

/*
 * Expand all single-line macro calls made in the given line.
 * Return the expanded version of the line. The original is deemed
 * to be destroyed in the process. (In reality we'll just move
 * Tokens from input to output a lot of the time, rather than
 * actually bothering to destroy and replicate.)
 */
static Token *
expand_smacro(Token * tline)
{
    Token *t, *tt, *mstart, **tail, *thead;
    SMacro *head = NULL, *m;
    Token **params;
    int *paramsize;
    int nparam, sparam, brackets, rescan;
    Token *org_tline = tline;
    Context *ctx;
    char *mname;

    /*
     * Trick: we should avoid changing the start token pointer since it can
     * be contained in "next" field of other token. Because of this
     * we allocate a copy of first token and work with it; at the end of
     * routine we copy it back
     */
    if (org_tline)
    {
      tline =
            new_Token(org_tline->next, org_tline->type, org_tline->text,
            0);
      tline->mac = org_tline->mac;
      nasm_free(org_tline->text);
      org_tline->text = NULL;
    }

  again:
    tail = &thead;
    thead = NULL;

    while (tline)
    {                   /* main token loop */
      if ((mname = tline->text))
      {
          /* if this token is a local macro, look in local context */
          if (tline->type == TOK_ID || tline->type == TOK_PREPROC_ID)
            ctx = get_ctx(mname, TRUE);
          else
            ctx = NULL;
          if (!ctx)
            head = smacros[hash(mname)];
          else
            head = ctx->localmac;
          /*
           * We've hit an identifier. As in is_mmacro below, we first
           * check whether the identifier is a single-line macro at
           * all, then think about checking for parameters if
           * necessary.
           */
          for (m = head; m; m = m->next)
            if (!mstrcmp(m->name, mname, m->casesense))
                break;
          if (m)
          {
            mstart = tline;
            params = NULL;
            paramsize = NULL;
            if (m->nparam == 0)
            {
                /*
                 * Simple case: the macro is parameterless. Discard the
                 * one token that the macro call took, and push the
                 * expansion back on the to-do stack.
                 */
                if (!m->expansion)
                {
                  if (!strcmp("__FILE__", m->name))
                  {
                      long num = 0;
                      nasm_src_get(&num, &(tline->text));
                      nasm_quote(&(tline->text));
                      tline->type = TOK_STRING;
                      continue;
                  }
                  if (!strcmp("__LINE__", m->name))
                  {
                      nasm_free(tline->text);
                      make_tok_num(tline, nasm_src_get_linnum());
                      continue;
                  }
                  tline = delete_Token(tline);
                  continue;
                }
            }
            else
            {
                /*
                 * Complicated case: at least one macro with this name
                 * exists and takes parameters. We must find the
                 * parameters in the call, count them, find the SMacro
                 * that corresponds to that form of the macro call, and
                 * substitute for the parameters when we expand. What a
                 * pain.
                 */
                /*tline = tline->next;
                skip_white_(tline);*/
                do {
                  t = tline->next;
                  while (tok_type_(t, TOK_SMAC_END))
                  {
                      t->mac->in_progress = FALSE;
                      t->text = NULL;
                      t = tline->next = delete_Token(t);
                  }
                  tline = t;
                } while (tok_type_(tline, TOK_WHITESPACE));
                if (!tok_is_(tline, "("))
                {
                  /*
                   * This macro wasn't called with parameters: ignore
                   * the call. (Behaviour borrowed from gnu cpp.)
                   */
                  tline = mstart;
                  m = NULL;
                }
                else
                {
                  int paren = 0;
                  int white = 0;
                  brackets = 0;
                  nparam = 0;
                  sparam = PARAM_DELTA;
                  params = nasm_malloc(sparam * sizeof(Token *));
                  params[0] = tline->next;
                  paramsize = nasm_malloc(sparam * sizeof(int));
                  paramsize[0] = 0;
                  while (TRUE)
                  {     /* parameter loop */
                      /*
                       * For some unusual expansions
                       * which concatenates function call
                       */
                      t = tline->next;
                      while (tok_type_(t, TOK_SMAC_END))
                      {
                        t->mac->in_progress = FALSE;
                        t->text = NULL;
                        t = tline->next = delete_Token(t);
                      }
                      tline = t;

                      if (!tline)
                      {
                        error(ERR_NONFATAL,
                              "macro call expects terminating `)'");
                        break;
                      }
                      if (tline->type == TOK_WHITESPACE
                            && brackets <= 0)
                      {
                        if (paramsize[nparam])
                            white++;
                        else
                            params[nparam] = tline->next;
                        continue;   /* parameter loop */
                      }
                      if (tline->type == TOK_OTHER
                            && tline->text[1] == 0)
                      {
                        char ch = tline->text[0];
                        if (ch == ',' && !paren && brackets <= 0)
                        {
                            if (++nparam >= sparam)
                            {
                              sparam += PARAM_DELTA;
                              params = nasm_realloc(params,
                                    sparam * sizeof(Token *));
                              paramsize = nasm_realloc(paramsize,
                                    sparam * sizeof(int));
                            }
                            params[nparam] = tline->next;
                            paramsize[nparam] = 0;
                            white = 0;
                            continue;     /* parameter loop */
                        }
                        if (ch == '{' &&
                              (brackets > 0 || (brackets == 0 &&
                                          !paramsize[nparam])))
                        {
                            if (!(brackets++))
                            {
                              params[nparam] = tline->next;
                              continue;   /* parameter loop */
                            }
                        }
                        if (ch == '}' && brackets > 0)
                            if (--brackets == 0)
                            {
                              brackets = -1;
                              continue;   /* parameter loop */
                            }
                        if (ch == '(' && !brackets)
                            paren++;
                        if (ch == ')' && brackets <= 0)
                            if (--paren < 0)
                              break;
                      }
                      if (brackets < 0)
                      {
                        brackets = 0;
                        error(ERR_NONFATAL, "braces do not "
                              "enclose all of macro parameter");
                      }
                      paramsize[nparam] += white + 1;
                      white = 0;
                  }     /* parameter loop */
                  nparam++;
                  while (m && (m->nparam != nparam ||
                              mstrcmp(m->name, mname,
                                    m->casesense)))
                      m = m->next;
                  if (!m)
                      error(ERR_WARNING | ERR_WARN_MNP,
                            "macro `%s' exists, "
                            "but not taking %d parameters",
                            mstart->text, nparam);
                }
            }
            if (m && m->in_progress)
                m = NULL;
            if (!m)           /* in progess or didn't find '(' or wrong nparam */
            {
                /* 
                 * Design question: should we handle !tline, which
                 * indicates missing ')' here, or expand those
                 * macros anyway, which requires the (t) test a few
                 * lines down?  
                 */
                nasm_free(params);
                nasm_free(paramsize);
                tline = mstart;
            }
            else
            {
                /*
                 * Expand the macro: we are placed on the last token of the
                 * call, so that we can easily split the call from the
                 * following tokens. We also start by pushing an SMAC_END
                 * token for the cycle removal.
                 */
                t = tline;
                if (t)
                {
                  tline = t->next;
                  t->next = NULL;
                }
                tt = new_Token(tline, TOK_SMAC_END, NULL, 0);
                tt->mac = m;
                m->in_progress = TRUE;
                tline = tt;
                for (t = m->expansion; t; t = t->next)
                {
                  if (t->type >= TOK_SMAC_PARAM)
                  {
                      Token *pcopy = tline, **ptail = &pcopy;
                      Token *ttt, *pt;
                      int i;

                      ttt = params[t->type - TOK_SMAC_PARAM];
                      for (i = paramsize[t->type - TOK_SMAC_PARAM];
                            --i >= 0;)
                      {
                        pt = *ptail =
                              new_Token(tline, ttt->type, ttt->text,
                              0);
                        ptail = &pt->next;
                        ttt = ttt->next;
                      }
                      tline = pcopy;
                  }
                  else
                  {
                      tt = new_Token(tline, t->type, t->text, 0);
                      tline = tt;
                  }
                }

                /*
                 * Having done that, get rid of the macro call, and clean
                 * up the parameters.
                 */
                nasm_free(params);
                nasm_free(paramsize);
                free_tlist(mstart);
                continue;     /* main token loop */
            }
          }
      }

      if (tline->type == TOK_SMAC_END)
      {
          tline->mac->in_progress = FALSE;
          tline = delete_Token(tline);
      }
      else
      {
          t = *tail = tline;
          tline = tline->next;
          t->mac = NULL;
          t->next = NULL;
          tail = &t->next;
      }
    }

    /*
     * Now scan the entire line and look for successive TOK_IDs that resulted
     * after expansion (they can't be produced by tokenise()). The successive
     * TOK_IDs should be concatenated.
     * Also we look for %+ tokens and concatenate the tokens before and after
     * them (without white spaces in between).
     */
    t = thead;
    rescan = 0;
    while (t)
    {
      while (t && t->type != TOK_ID && t->type != TOK_PREPROC_ID)
          t = t->next;
      if (!t || !t->next)
          break;
      if (t->next->type == TOK_ID ||
            t->next->type == TOK_PREPROC_ID ||
            t->next->type == TOK_NUMBER)
      {
          char *p = nasm_strcat(t->text, t->next->text);
          nasm_free(t->text);
          t->next = delete_Token(t->next);
          t->text = p;
          rescan = 1;
      }
      else if (t->next->type == TOK_WHITESPACE && t->next->next &&
            t->next->next->type == TOK_PREPROC_ID &&
            strcmp(t->next->next->text, "%+") == 0)
      {
          /* free the next whitespace, the %+ token and next whitespace */
          int i;
          for (i = 1; i <= 3; i++)
          {
            if (!t->next || (i != 2 && t->next->type != TOK_WHITESPACE))
                break;
            t->next = delete_Token(t->next);
          }             /* endfor */
      }
      else
          t = t->next;
    }
    /* If we concatenaded something, re-scan the line for macros */
    if (rescan)
    {
      tline = thead;
      goto again;
    }

    if (org_tline)
    {
      if (thead)
      {
          *org_tline = *thead;
          /* since we just gave text to org_line, don't free it */
          thead->text = NULL;
          delete_Token(thead);
      }
      else
      {
          /* the expression expanded to empty line;
             we can't return NULL for some reasons
             we just set the line to a single WHITESPACE token. */
          memset(org_tline, 0, sizeof(*org_tline));
          org_tline->text = NULL;
          org_tline->type = TOK_WHITESPACE;
      }
      thead = org_tline;
    }

    return thead;
}

/*
 * Similar to expand_smacro but used exclusively with macro identifiers
 * right before they are fetched in. The reason is that there can be
 * identifiers consisting of several subparts. We consider that if there
 * are more than one element forming the name, user wants a expansion,
 * otherwise it will be left as-is. Example:
 *
 *    %define %$abc cde
 *
 * the identifier %$abc will be left as-is so that the handler for %define
 * will suck it and define the corresponding value. Other case:
 *
 *    %define _%$abc cde
 *
 * In this case user wants name to be expanded *before* %define starts
 * working, so we'll expand %$abc into something (if it has a value;
 * otherwise it will be left as-is) then concatenate all successive
 * PP_IDs into one.
 */
static Token *
expand_id(Token * tline)
{
    Token *cur, *oldnext = NULL;

    if (!tline || !tline->next)
      return tline;

    cur = tline;
    while (cur->next &&
          (cur->next->type == TOK_ID ||
      cur->next->type == TOK_PREPROC_ID || cur->next->type == TOK_NUMBER))
      cur = cur->next;

    /* If identifier consists of just one token, don't expand */
    if (cur == tline)
      return tline;

    if (cur)
    {
      oldnext = cur->next;    /* Detach the tail past identifier */
      cur->next = NULL; /* so that expand_smacro stops here */
    }

    tline = expand_smacro(tline);

    if (cur)
    {
      /* expand_smacro possibly changhed tline; re-scan for EOL */
      cur = tline;
      while (cur && cur->next)
          cur = cur->next;
      if (cur)
          cur->next = oldnext;
    }

    return tline;
}

/*
 * Determine whether the given line constitutes a multi-line macro
 * call, and return the MMacro structure called if so. Doesn't have
 * to check for an initial label - that's taken care of in
 * expand_mmacro - but must check numbers of parameters. Guaranteed
 * to be called with tline->type == TOK_ID, so the putative macro
 * name is easy to find.
 */
static MMacro *
is_mmacro(Token * tline, Token *** params_array)
{
    MMacro *head, *m;
    Token **params;
    int nparam;

    head = mmacros[hash(tline->text)];

    /*
     * Efficiency: first we see if any macro exists with the given
     * name. If not, we can return NULL immediately. _Then_ we
     * count the parameters, and then we look further along the
     * list if necessary to find the proper MMacro.
     */
    for (m = head; m; m = m->next)
      if (!mstrcmp(m->name, tline->text, m->casesense))
          break;
    if (!m)
      return NULL;

    /*
     * OK, we have a potential macro. Count and demarcate the
     * parameters.
     */
    count_mmac_params(tline->next, &nparam, &params);

    /*
     * So we know how many parameters we've got. Find the MMacro
     * structure that handles this number.
     */
    while (m)
    {
      if (m->nparam_min <= nparam && (m->plus || nparam <= m->nparam_max))
      {
          /*
           * This one is right. Just check if cycle removal
           * prohibits us using it before we actually celebrate...
           */
          if (m->in_progress)
          {
#if 0
            error(ERR_NONFATAL,
                  "self-reference in multi-line macro `%s'", m->name);
#endif
            nasm_free(params);
            return NULL;
          }
          /*
           * It's right, and we can use it. Add its default
           * parameters to the end of our list if necessary.
           */
          if (m->defaults && nparam < m->nparam_min + m->ndefs)
          {
            params =
                  nasm_realloc(params,
                  ((m->nparam_min + m->ndefs + 1) * sizeof(*params)));
            while (nparam < m->nparam_min + m->ndefs)
            {
                params[nparam] = m->defaults[nparam - m->nparam_min];
                nparam++;
            }
          }
          /*
           * If we've gone over the maximum parameter count (and
           * we're in Plus mode), ignore parameters beyond
           * nparam_max.
           */
          if (m->plus && nparam > m->nparam_max)
            nparam = m->nparam_max;
          /*
           * Then terminate the parameter list, and leave.
           */
          if (!params)
          {             /* need this special case */
            params = nasm_malloc(sizeof(*params));
            nparam = 0;
          }
          params[nparam] = NULL;
          *params_array = params;
          return m;
      }
      /*
       * This one wasn't right: look for the next one with the
       * same name.
       */
      for (m = m->next; m; m = m->next)
          if (!mstrcmp(m->name, tline->text, m->casesense))
            break;
    }

    /*
     * After all that, we didn't find one with the right number of
     * parameters. Issue a warning, and fail to expand the macro.
     */
    error(ERR_WARNING | ERR_WARN_MNP,
          "macro `%s' exists, but not taking %d parameters",
          tline->text, nparam);
    nasm_free(params);
    return NULL;
}

/*
 * Expand the multi-line macro call made by the given line, if
 * there is one to be expanded. If there is, push the expansion on
 * istk->expansion and return 1. Otherwise return 0.
 */
static int
expand_mmacro(Token * tline)
{
    Token *startline = tline;
    Token *label = NULL;
    int dont_prepend = 0;
    Token **params, *t, *tt;
    MMacro *m;
    Line *l, *ll;
    int i, nparam, *paramlen;

    t = tline;
    skip_white_(t);
/*    if (!tok_type_(t, TOK_ID))  Lino 02/25/02 */
    if (!tok_type_(t, TOK_ID) && !tok_type_(t, TOK_PREPROC_ID))
      return 0;
    m = is_mmacro(t, &params);
    if (!m)
    {
      Token *last;
      /*
       * We have an id which isn't a macro call. We'll assume
       * it might be a label; we'll also check to see if a
       * colon follows it. Then, if there's another id after
       * that lot, we'll check it again for macro-hood.
       */
      label = last = t;
      t = t->next;
      if (tok_type_(t, TOK_WHITESPACE))
          last = t, t = t->next;
      if (tok_is_(t, ":"))
      {
          dont_prepend = 1;
          last = t, t = t->next;
          if (tok_type_(t, TOK_WHITESPACE))
            last = t, t = t->next;
      }
      if (!tok_type_(t, TOK_ID) || (m = is_mmacro(t, &params)) == NULL)
          return 0;
      last->next = NULL;
      tline = t;
    }

    /*
     * Fix up the parameters: this involves stripping leading and
     * trailing whitespace, then stripping braces if they are
     * present.
     */
    for (nparam = 0; params[nparam]; nparam++)
      ;
    paramlen = nparam ? nasm_malloc(nparam * sizeof(*paramlen)) : NULL;

    for (i = 0; params[i]; i++)
    {
      int brace = FALSE;
      int comma = (!m->plus || i < nparam - 1);

      t = params[i];
      skip_white_(t);
      if (tok_is_(t, "{"))
          t = t->next, brace = TRUE, comma = FALSE;
      params[i] = t;
      paramlen[i] = 0;
      while (t)
      {
          if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
            break;            /* ... because we have hit a comma */
          if (comma && t->type == TOK_WHITESPACE && tok_is_(t->next, ","))
            break;            /* ... or a space then a comma */
          if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
            break;            /* ... or a brace */
          t = t->next;
          paramlen[i]++;
      }
    }

    /*
     * OK, we have a MMacro structure together with a set of
     * parameters. We must now go through the expansion and push
     * copies of each Line on to istk->expansion. Substitution of
     * parameter tokens and macro-local tokens doesn't get done
     * until the single-line macro substitution process; this is
     * because delaying them allows us to change the semantics
     * later through %rotate.
     *
     * First, push an end marker on to istk->expansion, mark this
     * macro as in progress, and set up its invocation-specific
     * variables.
     */
    ll = nasm_malloc(sizeof(Line));
    ll->next = istk->expansion;
    ll->finishes = m;
    ll->first = NULL;
    istk->expansion = ll;

    m->in_progress = TRUE;
    m->params = params;
    m->iline = tline;
    m->nparam = nparam;
    m->rotate = 0;
    m->paramlen = paramlen;
    m->unique = unique++;
    m->lineno = 0;

    m->next_active = istk->mstk;
    istk->mstk = m;

    for (l = m->expansion; l; l = l->next)
    {
      Token **tail;

      ll = nasm_malloc(sizeof(Line));
      ll->finishes = NULL;
      ll->next = istk->expansion;
      istk->expansion = ll;
      tail = &ll->first;

      for (t = l->first; t; t = t->next)
      {
          Token *x = t;
          if (t->type == TOK_PREPROC_ID &&
                t->text[1] == '0' && t->text[2] == '0')
          {
            dont_prepend = -1;
            x = label;
            if (!x)
                continue;
          }
          tt = *tail = new_Token(NULL, x->type, x->text, 0);
          tail = &tt->next;
      }
      *tail = NULL;
    }

    /*
     * If we had a label, push it on as the first line of
     * the macro expansion.
     */
    if (label)
    {
      if (dont_prepend < 0)
          free_tlist(startline);
      else
      {
          ll = nasm_malloc(sizeof(Line));
          ll->finishes = NULL;
          ll->next = istk->expansion;
          istk->expansion = ll;
          ll->first = startline;
          if (!dont_prepend)
          {
            while (label->next)
                label = label->next;
            label->next = tt = new_Token(NULL, TOK_OTHER, ":", 0);
          }
      }
    }

    list->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);

    return 1;
}

/*
 * Since preprocessor always operate only on the line that didn't
 * arrived yet, we should always use ERR_OFFBY1. Also since user
 * won't want to see same error twice (preprocessing is done once
 * per pass) we will want to show errors only during pass one.
 */
static void
error(int severity, const char *fmt, ...)
{
    va_list arg;
    char buff[1024];

    /* If we're in a dead branch of IF or something like it, ignore the error */
    if (istk && istk->conds && !emitting(istk->conds->state))
      return;

    va_start(arg, fmt);
    vsprintf(buff, fmt, arg);
    va_end(arg);

    if (istk && istk->mstk && istk->mstk->name)
      _error(severity | ERR_PASS1, "(%s:%d) %s", istk->mstk->name,
            istk->mstk->lineno, buff);
    else 
      _error(severity | ERR_PASS1, "%s", buff);
}

static void
pp_reset(FILE *f, const char *file, int apass, efunc errfunc, evalfunc eval,
      ListGen * listgen)
{
    int h;

    first_fp = f;
    _error = errfunc;
    cstk = NULL;
    istk = nasm_malloc(sizeof(Include));
    istk->next = NULL;
    istk->conds = NULL;
    istk->expansion = NULL;
    istk->mstk = NULL;
    istk->fp = f;
    istk->fname = NULL;
    nasm_src_set_fname(nasm_strdup(file));
    nasm_src_set_linnum(0);
    istk->lineinc = 1;
    defining = NULL;
    for (h = 0; h < NHASH; h++)
    {
      mmacros[h] = NULL;
      smacros[h] = NULL;
    }
    unique = 0;
      if (tasm_compatible_mode) {
          stdmacpos = stdmac;
      } else {
            stdmacpos = &stdmac[TASM_MACRO_COUNT];
      }
    any_extrastdmac = (extrastdmac != NULL);
    list = listgen;
    evaluate = eval;
    pass = apass;
}

static char *
pp_getline(void)
{
    char *line;
    Token *tline;

    while (1)
    {
      /*
       * Fetch a tokenised line, either from the macro-expansion
       * buffer or from the input file.
       */
      tline = NULL;
      while (istk->expansion && istk->expansion->finishes)
      {
          Line *l = istk->expansion;
          if (!l->finishes->name && l->finishes->in_progress > 1)
          {
            Line *ll;

            /*
             * This is a macro-end marker for a macro with no
             * name, which means it's not really a macro at all
             * but a %rep block, and the `in_progress' field is
             * more than 1, meaning that we still need to
             * repeat. (1 means the natural last repetition; 0
             * means termination by %exitrep.) We have
             * therefore expanded up to the %endrep, and must
             * push the whole block on to the expansion buffer
             * again. We don't bother to remove the macro-end
             * marker: we'd only have to generate another one
             * if we did.
             */
            l->finishes->in_progress--;
            for (l = l->finishes->expansion; l; l = l->next)
            {
                Token *t, *tt, **tail;

                ll = nasm_malloc(sizeof(Line));
                ll->next = istk->expansion;
                ll->finishes = NULL;
                ll->first = NULL;
                tail = &ll->first;

                for (t = l->first; t; t = t->next)
                {
                  if (t->text || t->type == TOK_WHITESPACE)
                  {
                      tt = *tail = new_Token(NULL, t->type, t->text, 0);
                      tail = &tt->next;
                  }
                }

                istk->expansion = ll;
            }
          }
          else
          {
            /*
             * Check whether a `%rep' was started and not ended
             * within this macro expansion. This can happen and
             * should be detected. It's a fatal error because
             * I'm too confused to work out how to recover
             * sensibly from it.
             */
            if (defining)
            {
                if (defining->name)
                  error(ERR_PANIC, "defining with name in expansion");
                else if (istk->mstk->name)
                  error(ERR_FATAL, "`%%rep' without `%%endrep' within"
                        " expansion of macro `%s'", istk->mstk->name);
            }

            /*
             * FIXME:  investigate the relationship at this point between
             * istk->mstk and l->finishes
             */
            {
                MMacro *m = istk->mstk;
                istk->mstk = m->next_active;
                if (m->name)
                {
                  /*
                   * This was a real macro call, not a %rep, and
                   * therefore the parameter information needs to
                   * be freed.
                   */
                  nasm_free(m->params);
                  free_tlist(m->iline);
                  nasm_free(m->paramlen);
                  l->finishes->in_progress = FALSE;
                }
                else
                  free_mmacro(m);
            }
            istk->expansion = l->next;
            nasm_free(l);
            list->downlevel(LIST_MACRO);
          }
      }
      while (1)
      {                 /* until we get a line we can use */

          if (istk->expansion)
          {             /* from a macro expansion */
            char *p;
            Line *l = istk->expansion;
            if (istk->mstk)
                istk->mstk->lineno++;
            tline = l->first;
            istk->expansion = l->next;
            nasm_free(l);
            p = detoken(tline, FALSE);
            list->line(LIST_MACRO, p);
            nasm_free(p);
            break;
          }
          line = read_line();
          if (line)
          {             /* from the current input file */
            line = prepreproc(line);
            tline = tokenise(line);
            nasm_free(line);
            break;
          }
          /*
           * The current file has ended; work down the istk
           */
          {
            Include *i = istk;
            if (i->fp != first_fp)
                fclose(i->fp);
            if (i->conds)
                error(ERR_FATAL, "expected `%%endif' before end of file");
            /* only set line and file name if there's a next node */
            if (i->next) 
            {
                nasm_src_set_linnum(i->lineno);
                nasm_free(nasm_src_set_fname(nasm_strdup(i->fname)));
            }
            istk = i->next;
            list->downlevel(LIST_INCLUDE);
            nasm_free(i);
            if (!istk)
                return NULL;
          }
      }

      /*
       * We must expand MMacro parameters and MMacro-local labels
       * _before_ we plunge into directive processing, to cope
       * with things like `%define something %1' such as STRUC
       * uses. Unless we're _defining_ a MMacro, in which case
       * those tokens should be left alone to go into the
       * definition; and unless we're in a non-emitting
       * condition, in which case we don't want to meddle with
       * anything.
       */
      if (!defining && !(istk->conds && !emitting(istk->conds->state)))
          tline = expand_mmac_params(tline);

      /*
       * Check the line to see if it's a preprocessor directive.
       */
      if (do_directive(tline) == DIRECTIVE_FOUND)
      {
          continue;
      }
      else if (defining)
      {
          /*
           * We're defining a multi-line macro. We emit nothing
           * at all, and just
           * shove the tokenised line on to the macro definition.
           */
          Line *l = nasm_malloc(sizeof(Line));
          l->next = defining->expansion;
          l->first = tline;
          l->finishes = FALSE;
          defining->expansion = l;
          continue;
      }
      else if (istk->conds && !emitting(istk->conds->state))
      {
          /*
           * We're in a non-emitting branch of a condition block.
           * Emit nothing at all, not even a blank line: when we
           * emerge from the condition we'll give a line-number
           * directive so we keep our place correctly.
           */
          free_tlist(tline);
          continue;
      }
      else if (istk->mstk && !istk->mstk->in_progress)
      {
          /*
           * We're in a %rep block which has been terminated, so
           * we're walking through to the %endrep without
           * emitting anything. Emit nothing at all, not even a
           * blank line: when we emerge from the %rep block we'll
           * give a line-number directive so we keep our place
           * correctly.
           */
          free_tlist(tline);
          continue;
      }
      else
      {
          tline = expand_smacro(tline);
          if (!expand_mmacro(tline))
          {
            /*
             * De-tokenise the line again, and emit it.
             */
            line = detoken(tline, TRUE);
            free_tlist(tline);
            break;
          }
          else
          {
            continue;   /* expand_mmacro calls free_tlist */
          }
      }
    }

    return line;
}

static void
pp_cleanup(int pass_)
{
    int h;

    if (defining)
    {
      error(ERR_NONFATAL, "end of file while still defining macro `%s'",
            defining->name);
      free_mmacro(defining);
    }
    while (cstk)
      ctx_pop();
    for (h = 0; h < NHASH; h++)
    {
      while (mmacros[h])
      {
          MMacro *m = mmacros[h];
          mmacros[h] = mmacros[h]->next;
          free_mmacro(m);
      }
      while (smacros[h])
      {
          SMacro *s = smacros[h];
          smacros[h] = smacros[h]->next;
          nasm_free(s->name);
          free_tlist(s->expansion);
          nasm_free(s);
      }
    }
    while (istk)
    {
      Include *i = istk;
      istk = istk->next;
      if (i->fp != first_fp)
          fclose(i->fp);
      nasm_free(i->fname);
      nasm_free(i);
    }
    while (cstk)
      ctx_pop();
    if (pass_ == 0)
      {
            free_llist(predef);
            delete_Blocks();
      }
}

void
pp_include_path(const char *path)
{
    IncPath *i;
/*  by alexfru: order of path inclusion fixed (was reverse order) */
    i = nasm_malloc(sizeof(IncPath));
    i->path = nasm_strdup(path);
    i->next = NULL;

    if (ipath != NULL)
    { 
        IncPath *j = ipath; 
        while (j->next != NULL)
            j = j->next; 
        j->next = i; 
    }
    else
    {
      ipath = i;
    }
} 

void
pp_pre_include(const char *fname)
{
    Token *inc, *space, *name;
    Line *l;

    name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
    space = new_Token(name, TOK_WHITESPACE, NULL, 0);
    inc = new_Token(space, TOK_PREPROC_ID, "%include", 0);

    l = nasm_malloc(sizeof(Line));
    l->next = predef;
    l->first = inc;
    l->finishes = FALSE;
    predef = l;
}

void
pp_pre_define(char *definition)
{
    Token *def, *space;
    Line *l;
    char *equals;

    equals = strchr(definition, '=');
    space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
    def = new_Token(space, TOK_PREPROC_ID, "%define", 0);
    if (equals)
      *equals = ' ';
    space->next = tokenise(definition);
    if (equals)
      *equals = '=';

    l = nasm_malloc(sizeof(Line));
    l->next = predef;
    l->first = def;
    l->finishes = FALSE;
    predef = l;
}

void
pp_pre_undefine(char *definition)
{
    Token *def, *space;
    Line *l;

    space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
    def = new_Token(space, TOK_PREPROC_ID, "%undef", 0);
    space->next = tokenise(definition);

    l = nasm_malloc(sizeof(Line));
    l->next = predef;
    l->first = def;
    l->finishes = FALSE;
    predef = l;
}

void
pp_extra_stdmac(const char **macros)
{
    extrastdmac = macros;
}

static void
make_tok_num(Token * tok, long val)
{
    char numbuf[20];
    sprintf(numbuf, "%ld", val);
    tok->text = nasm_strdup(numbuf);
    tok->type = TOK_NUMBER;
}

Preproc nasmpp = {
    pp_reset,
    pp_getline,
    pp_cleanup
};

Generated by  Doxygen 1.6.0   Back to index