mirror/nasm
2
0
Fork 0
mirror of https://github.com/netwide-assembler/nasm.git synced 2024-11-21 03:14:19 +08:00
Code Issues Packages Projects Releases Wiki Activity
a77955580e
nasm/preproc.c
H. Peter Anvin 0c60815d91 Undo broken %elif change, and put in a big comment explaining why the 
existing code is correct.
2002-05-22 22:59:40 +00:00

4435 lines
105 KiB
C
Raw Blame History

/* -*- 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 <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include "nasm.h"
#include "nasmlib.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 )
/*
* 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 char *StackPointer = "ebp";
static int ArgOffset = 8;
static int LocalOffset = 4;
static Context *cstk;
static Include *istk;
static IncPath *ipath = 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 "macros.c"
static const char **stdmacpos;
/*
* The extra standard macros that come from the object format, if
* any.
*/
static 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, 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, len;
char *p = line, *oldline, oldchar;
/* Skip whitespace */
while (isspace(*p) && *p != 0)
p++;
/* Binary search for the directive name */
i = -1;
j = sizeof(tasm_directives) / sizeof(*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, 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, 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;
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 >= sizeof(multipliers) / sizeof(*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, bufsize);
p = buffer + offset; /* prevent stale-pointer problems */
}
}
if (!q && p == buffer)
{
nasm_free(buffer);
return NULL;
}
src_set_linnum(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");
}
}
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++;
}
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, 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 + txtlen);
strncpy(t->text, text, 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 *p = getenv(t->text + 2);
nasm_free(t->text);
if (p)
t->text = nasm_strdup(p);
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 *p, *q = t->text + 2;
q += strspn(q, "$");
sprintf(buffer, "..@%lu.", ctx->number);
p = nasm_strcat(buffer, q);
nasm_free(t->text);
t->text = p;
}
}
if (t->type == TOK_WHITESPACE)
{
len++;
}
else if (t->text)
{
len += strlen(t->text);
}
}
p = line = nasm_malloc(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[1])
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 = 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 = 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;
char *prefix = "", *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;
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;
}
else if (tt->type == TOK_WHITESPACE)
{
tt = tt->next;
continue;
}
else if (tt->type != t->type ||
mstrcmp(tt->text, t->text, casesense))
{
j = FALSE; /* found mismatching tokens */
break;
}
else
{
t = t->next;
tt = tt->next;
continue;
}
}
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 =
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 = 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 (!is_simple(evalresult))
{
error(ERR_NONFATAL,
"non-constant value given to `%s'", directives[i]);
return -1;
}
return 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.
*/
void
expand_macros_in_string(char **p)
{
Token *line = tokenise(*p);
line = expand_smacro(line);
*p = detoken(line, FALSE);
}
/*
* Find out if a line contains a preprocessor directive, and deal
* with it if so.
*
* If a directive _is_ found, we are expected to free_tlist() the
* line.
*
* Return values go like this:
*
* bit 0 is set if a directive was found (so the line gets freed)
*/
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;
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 0;
i = -1;
j = sizeof(directives) / sizeof(*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 0;
}
/*
* 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 0;
}
if (j != -2)
{
error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
tline->text);
return 0; /* 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 3;
}
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 3;
}
free_tlist(origline);
return 3;
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 3;
}
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 3;
}
tline = tline->next;
if (!tline || tline->type != TOK_ID)
{
error(ERR_NONFATAL,
"`%%arg' missing size type parameter");
free_tlist(origline);
return 3;
}
/* 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 3;
}
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 3;
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 3;
}
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 3;
}
tline = tline->next;
if (!tline || tline->type != TOK_ID)
{
error(ERR_NONFATAL,
"`%%local' missing size type parameter");
free_tlist(origline);
return 3;
}
/* 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 3;
}
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 3;
case PP_CLEAR:
if (tline->next)
error(ERR_WARNING,
"trailing garbage after `%%clear' ignored");
for (j = 0; j < NHASH; j++)
{
while (mmacros[j])
{
MMacro *m = mmacros[j];
mmacros[j] = m->next;
free_mmacro(m);
}
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 3;
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 3; /* 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 = src_set_fname(p);
inc->lineno = src_set_linnum(0);
inc->lineinc = 1;
inc->expansion = NULL;
inc->mstk = NULL;
istk = inc;
list->uplevel(LIST_INCLUDE);
free_tlist(origline);
return 5;
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 3; /* 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 3; /* 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 (j == COND_IF_TRUE ? 3 : 1);
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 (istk->conds->state == COND_IF_TRUE ? 5 : 1);
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 5;
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 5;
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 3;
}
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 =
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 = 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 1;
case PP_ENDM:
case PP_ENDMACRO:
if (!defining)
{
error(ERR_NONFATAL, "`%s': not defining a macro",
tline->text);
return 3;
}
k = hash(defining->name);
defining->next = mmacros[k];
mmacros[k] = defining;
defining = NULL;
free_tlist(origline);
return 5;
case PP_ROTATE:
if (tline->next && tline->next->type == TOK_WHITESPACE)
tline = tline->next;
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 3;
if (tokval.t_type)
error(ERR_WARNING,
"trailing garbage after expression ignored");
if (!is_simple(evalresult))
{
error(ERR_NONFATAL, "non-constant value given to `%%rotate'");
return 3;
}
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");
mmac->rotate = mmac->rotate + reloc_value(evalresult);
if (mmac->rotate < 0)
mmac->rotate = mmac->nparam - (-mmac->rotate) % mmac->nparam;
mmac->rotate %= mmac->nparam;
return 1;
case PP_REP:
nolist = FALSE;
tline = tline->next;
if (tline->next && tline->next->type == TOK_WHITESPACE)
tline = tline->next;
if (tline->next && tline->next->type == TOK_ID &&
!nasm_stricmp(tline->next->text, ".nolist"))
{
tline = tline->next;
nolist = TRUE;
}
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 3;
if (tokval.t_type)
error(ERR_WARNING,
"trailing garbage after expression ignored");
if (!is_simple(evalresult))
{
error(ERR_NONFATAL, "non-constant value given to `%%rep'");
return 3;
}
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 = reloc_value(evalresult) + 1;
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 1;
case PP_ENDREP:
if (!defining || defining->name)
{
error(ERR_NONFATAL, "`%%endrep': no matching `%%rep'");
return 3;
}
/*
* 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 1;
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 1;
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 3;
}
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 3;
}
if (tline->type != TOK_ID)
{
error(ERR_NONFATAL,
"`%s': parameter identifier expected",
tline->text);
free_tlist(origline);
return 3;
}
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 3;
}
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 3;
}
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 3;
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 3;
}
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 3;
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 3;
}
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 3;
}
macro_start = nasm_malloc(sizeof(*macro_start));
macro_start->next = NULL;
make_tok_num(macro_start, 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 3;
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 3;
}
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 3;
}
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 3;
}
if (!is_simple(evalresult))
{
error(ERR_NONFATAL, "non-constant value given to `%%substr`");
free_tlist(tline);
free_tlist(origline);
return 3;
}
macro_start = nasm_malloc(sizeof(*macro_start));
macro_start->next = NULL;
macro_start->text = nasm_strdup("'''");
if (evalresult->value > 0
&& evalresult->value < 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 3;
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 3;
}
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 3;
}
if (tokval.t_type)
error(ERR_WARNING,
"trailing garbage after expression ignored");
if (!is_simple(evalresult))
{
error(ERR_NONFATAL,
"non-constant value given to `%%%sassign'",
(i == PP_IASSIGN ? "i" : ""));
free_tlist(origline);
return 3;
}
macro_start = nasm_malloc(sizeof(*macro_start));
macro_start->next = NULL;
make_tok_num(macro_start, 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 3;
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 3;
}
k = 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 3;
}
m = readnum(tline->text, &j);
tline = tline->next;
}
skip_white_(tline);
src_set_linnum(k);
istk->lineinc = m;
if (tline)
{
nasm_free(src_set_fname(detoken(tline, FALSE)));
}
free_tlist(origline);
return 5;
default:
error(ERR_FATAL,
"preprocessor directive `%s' not yet implemented",
directives[i]);
break;
}
return 3;
}
/*
* 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 = sizeof(conditions) / sizeof(*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;
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, 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);
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;
tline = tline->next;
sparam = PARAM_DELTA;
params = nasm_malloc(sparam * sizeof(Token *));
params[0] = tline;
paramsize = nasm_malloc(sparam * sizeof(int));
paramsize[0] = 0;
for (;; tline = tline->next)
{ /* parameter loop */
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(char *file, int apass, efunc errfunc, evalfunc eval,
ListGen * listgen)
{
int h;
_error = errfunc;
cstk = NULL;
istk = nasm_malloc(sizeof(Include));
istk->next = NULL;
istk->conds = NULL;
istk->expansion = NULL;
istk->mstk = NULL;
istk->fp = fopen(file, "r");
istk->fname = NULL;
src_set_fname(nasm_strdup(file));
src_set_linnum(0);
istk->lineinc = 1;
if (!istk->fp)
error(ERR_FATAL | ERR_NOFILE, "unable to open input file `%s'", file);
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;
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)
{
src_set_linnum(i->lineno);
nasm_free(src_set_fname(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) & 1)
{
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;
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(char *path)
{
IncPath *i;
i = nasm_malloc(sizeof(IncPath));
i->path = nasm_strdup(path);
i->next = ipath;
ipath = i;
}
void
pp_pre_include(char *fname)
{
Token *inc, *space, *name;
Line *l;
name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
space = new_Token(name, TOK_WHITESPACE, NULL, 0);
inc = new_Token(space, TOK_PREPROC_ID, "%include", 0);
l = nasm_malloc(sizeof(Line));
l->next = predef;
l->first = inc;
l->finishes = 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);
l = nasm_malloc(sizeof(Line));
l->next = predef;
l->first = def;
l->finishes = FALSE;
predef = l;
}
void
pp_extra_stdmac(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
};
Reference in New Issue View Git Blame Copy Permalink