Google Git
Sign in
chromium/chromium/deps/nasm/refs/tags/nasm-3.01rc9/./asm/preproc.c
blob: cf028e7b6215407a776eae2ba50b5c5b2bb60313 [file]
/* SPDX-License-Identifier: BSD-2-Clause */
/* Copyright 1996-2025 The NASM Authors - All Rights Reserved */
/*
* preproc.c macro preprocessor for the Netwide Assembler
*/
/* Typical flow of text through preproc
*
* pp_getline gets tokenized lines, either
*
* from a macro expansion
*
* or
* {
* read_line gets raw text from stdmacs, predef, or current input file
* tokenize 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 "compiler.h"
#include "nctype.h"
#include "nasm.h"
#include "nasmlib.h"
#include "assemble.h"
#include "error.h"
#include "preproc.h"
#include "hashtbl.h"
#include "quote.h"
#include "stdscan.h"
#include "eval.h"
#include "tokens.h"
#include "tables.h"
#include "listing.h"
#include "dbginfo.h"
/*
* This is a very slow option, but it can catch some
* serious problems...
*/
#ifndef DEBUG_MMACRO_REFCOUNTS
# define DEBUG_MMACRO_REFCOUNTS 0
#endif
/*
* Preprocessor execution options that can be controlled by %pragma or
* other directives. This structure is initialized to zero on each
* pass; this *must* reflect the default initial state.
*/
static struct pp_config {
bool noaliases;
bool sane_empty_expansion;
} ppconf;
/*
* Preprocessor debug-related flags
*/
static enum pp_debug_flags {
PDBG_MMACROS = 1, /* Collect mmacro information */
PDBG_SMACROS = 2, /* Collect smacro information */
PDBG_LIST_SMACROS = 4, /* Smacros to list file (list option 's') */
PDBG_INCLUDE = 8 /* Collect %include information */
} ppdbg;
/*
* Preprocessor options configured on the command line
*/
static enum preproc_opt ppopt;
typedef struct SMacro SMacro;
typedef struct MMacro MMacro;
typedef struct Context Context;
typedef struct Token Token;
typedef struct Line Line;
typedef struct Include Include;
typedef struct Cond Cond;
/*
* The current set of multi-line macros we have defined.
*/
static struct hash_table mmacros;
/*
* The current set of single-line macros we have defined.
*/
static struct hash_table smacros;
/*
* The multi-line macro we are currently defining, or the %rep
* block we are currently reading, if any.
*/
static MMacro *defining;
/*
* Map of preprocessor directives that are also preprocessor functions;
* if they are at the beginning of a line they are a function if and
* only if they are followed by a (
*/
static bool pp_op_may_be_function[PP_count];
/*
* This is the internal form which we break input lines up into.
* Typically stored in linked lists.
*
* Note that `type' serves a double meaning: TOKEN_SMAC_START_PARAMS is
* not necessarily used as-is, but is also used to encode the number
* and expansion type of 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(0) but the one representing `y' will be
* tok_smac_param(1); see the accessor functions below.
*
* TOKEN_INTERNAL_STR is a string which has been unquoted, but should
* be treated as if it was a quoted string. The code is free to change
* one into the other at will. TOKEN_NAKED_STR is a text token which
* should be treated as a string, but which MUST NOT be turned into a
* quoted string. TOKEN_INTERNAL_STRs can contain any character,
* including NUL, but TOKEN_NAKED_STR must be a valid C string.
*/
static inline enum token_type tok_smac_param(int param)
{
return TOKEN_SMAC_START_PARAMS + param;
}
static int smac_nparam(enum token_type toktype)
{
return toktype - TOKEN_SMAC_START_PARAMS;
}
static bool is_smac_param(enum token_type toktype)
{
return toktype >= TOKEN_SMAC_START_PARAMS;
}
/*
* This is tuned so struct Token should be 64 bytes on 64-bit
* systems and 32 bytes on 32-bit systems. It enables them
* to be nicely cache aligned, and the text to still be kept
* inline for nearly all tokens.
*
* We prohibit tokens of length > MAX_TEXT even though
* length here is an unsigned int; this avoids problems
* if the length is passed through an interface with type "int",
* and is absurdly large anyway.
*
* Earlier versions of the source code incorrectly stated that
* examining the text string alone can be unconditionally valid. This
* is incorrect, as some token types strip parts of the string,
* e.g. indirect tokens.
*/
#define INLINE_TEXT (7*sizeof(char *)-sizeof(enum token_type)-sizeof(unsigned int)-1)
#define MAX_TEXT (INT_MAX-2)
struct Token {
Token *next;
unsigned int len;
enum token_type type;
union {
char a[INLINE_TEXT+1];
struct {
char pad[INLINE_TEXT+1 - sizeof(char *)];
char *ptr;
} p;
} text;
};
/*
* Note on the storage of both SMacro and MMacros: the hash table
* indexes them case-insensitively, and we then have to go through a
* linked list of potential case aliases (and, for MMacros, parameter
* ranges); this is to preserve the matching semantics of the earlier
* code. If the number of case aliases for a specific macro is a
* performance issue, you may want to reconsider your coding style.
*/
/*
* Function call tp obtain the expansion of an smacro
*/
typedef Token *(*ExpandSMacro)(const SMacro *s, Token **params, int nparams);
/*
* Store the definition of a single-line macro.
*
* Note: for user-defined macros, SPARM_VARADIC and SPARM_DEFAULT are
* currently never set, and SPARM_OPTIONAL is set if and only
* if SPARM_GREEDY is set.
*/
enum sparmflags {
SPARM_PLAIN = 0,
SPARM_EVAL = 1, /* Evaluate as a numeric expression (=) */
SPARM_STR = 2, /* Convert to quoted string ($) */
SPARM_NOSTRIP = 4, /* Don't strip braces (!) */
SPARM_GREEDY = 8, /* Greedy final parameter (+) */
SPARM_VARADIC = 16, /* Any number of separate arguments */
SPARM_OPTIONAL = 32, /* Optional argument */
SPARM_CONDQUOTE = 64, /* With SPARM_STR, don't re-quote a string */
SPARM_UNSIGNED = 128 /* With SPARM_EVAL, generate unsigned numbers */
};
struct smac_param {
Token name;
enum sparmflags flags;
char radix; /* Radix type for SPARM_EVAL */
const Token *def; /* Default, if any */
};
struct SMacro {
SMacro *next; /* MUST BE FIRST - see free_smacro() */
char *name;
Token *expansion;
ExpandSMacro expand;
intorptr expandpvt;
struct smac_param *params;
int nparam; /* length of the params structure */
int nparam_min; /* allows < nparam arguments */
int in_progress;
bool recursive;
bool varadic; /* greedy or supports > nparam arguments */
bool casesense;
bool alias; /* This is an alias macro */
};
/*
* "No listing" flags. Inside a loop (%rep..%endrep) we may have
* macro listing suppressed with .nolist, but we still need to
* update line numbers for error messages and debug information...
* unless we are nested inside an actual .nolist macro.
*/
enum nolist_flags {
NL_LIST = 1, /* Suppress list output */
NL_LINE = 2 /* Don't update line information */
};
/*
* 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.
*/
/*
* Expansion stack. Note that .mmac can point back to the macro itself,
* whereas .mstk cannot.
*/
struct mstk {
MMacro *mstk; /* Any expansion, real macro or not */
MMacro *mmac; /* Highest level actual mmacro */
};
struct MMacro {
MMacro *next;
#if 0
MMacroInvocation *prev; /* previous invocation */
#endif
size_t refcnt; /* references to this macro */
#if DEBUG_MMACRO_REFCOUNTS
struct {
size_t cnt;
MMacro *next;
} refdbg;
#endif
char *name;
int nparam_min, nparam_max;
enum nolist_flags nolist; /* is this macro listing-inhibited? */
bool casesense;
bool plus; /* is the last parameter greedy? */
bool capture_label; /* macro definition has %00; capture label */
int32_t in_progress; /* is this macro currently being expanded? */
int32_t max_depth; /* maximum number of recursive expansions allowed */
Token *dlist; /* All defaults as one list */
Token **defaults; /* Parameter default pointers */
int ndefs; /* number of default parameters */
Line *expansion;
struct mstk mstk; /* Macro expansion stack */
struct mstk dstk; /* Macro definitions stack */
Token **params; /* actual parameters */
Token *iline; /* invocation line */
struct src_location where; /* location of definition */
unsigned int nparam, rotate;
char *iname; /* name invoked as */
int *paramlen;
uint64_t unique;
uint64_t condcnt; /* number of if blocks... */
struct { /* Debug information */
struct debug_macro_def *def; /* Definition */
struct debug_macro_inv *inv; /* Current invocation (if any) */
} dbg;
};
/* Store the definition of a multi-line macro, as defined in a
* previous recursive macro expansion.
*/
#if 0
struct MMacroInvocation {
MMacroInvocation *prev; /* previous invocation */
Token **params; /* actual parameters */
Token *iline; /* invocation line */
unsigned int nparam, rotate;
int *paramlen;
uint64_t unique;
uint64_t condcnt;
};
#endif
#if DEBUG_MMACRO_REFCOUNTS
static void check_mmacro_refcounts(void);
static MMacro *refdbg_list;
#else
# define check_mmacro_refcounts() ((void)0)
#endif
/*
* MMacros are reference counted: each of the following adds a reference:
* - adding to a linked list (via ->next)
* - mstk.mstk, mstk.mmac, dstk.mstk dstk.mmac
* - defining
* - Line::finishes
* - src_macro
*
* These functions help manage the reference counts.
*/
static void free_mmacro(MMacro *m);
static MMacro *get_mmacro(MMacro *m)
{
if (m)
m->refcnt++;
return m;
}
static MMacro *pop_mmacro(MMacro **mp, MMacro *next)
{
MMacro *m = *mp;
*mp = next;
if (m) {
nasm_assert(m->refcnt > 0);
if (!--m->refcnt) {
if (m->name) {
nasm_debug(2, "freeing macro `%s'", m->name);
check_mmacro_refcounts();
}
nasm_assert(!m->next);
free_mmacro(m);
}
}
return next;
}
static void put_mmacro(MMacro **mp)
{
pop_mmacro(mp, NULL);
}
static void pop_mstk(struct mstk *msp, MMacro *nextp)
{
struct mstk next = { NULL, NULL };
if (nextp) {
/* Read before possible freeing action */
next = nextp->mstk;
}
pop_mmacro(&msp->mmac, next.mmac);
pop_mmacro(&msp->mstk, next.mstk);
}
/*
* The context stack is composed of a linked list of these.
*/
struct Context {
Context *next;
const char *name;
struct hash_table localmac;
uint64_t number;
unsigned int depth;
};
static inline const char *tok_text(const struct Token *t)
{
return (t->len <= INLINE_TEXT) ? t->text.a : t->text.p.ptr;
}
/*
* Returns a mutable pointer to the text buffer. The text can be changed,
* but the length MUST NOT CHANGE, in either direction; nor is it permitted
* to pad with null characters to create an artificially shorter string.
*/
static inline char *tok_text_buf(struct Token *t)
{
return (t->len <= INLINE_TEXT) ? t->text.a : t->text.p.ptr;
}
static inline unsigned int tok_check_len(size_t len)
{
if (unlikely(len > MAX_TEXT))
nasm_fatal("impossibly large token");
return len;
}
static inline bool tok_text_match(const struct Token *a, const struct Token *b)
{
return a->len == b->len && !memcmp(tok_text(a), tok_text(b), a->len);
}
static inline unused_func bool
tok_match(const struct Token *a, const struct Token *b)
{
return a->type == b->type && tok_text_match(a, b);
}
/* strlen() variant useful for set_text() and its variants */
static size_t tok_strlen(const char *str)
{
return strnlen(str, MAX_TEXT+1);
}
/*
* Set the text field to a copy of the given string; the length if
* not given should be obtained with tok_strlen().
*/
static Token *set_text(struct Token *t, const char *text, size_t len)
{
char *textp;
if (t->len > INLINE_TEXT)
nasm_free(t->text.p.ptr);
nasm_zero(t->text);
t->len = len = tok_check_len(len);
textp = (len > INLINE_TEXT)
? (t->text.p.ptr = nasm_malloc(len+1)) : t->text.a;
memcpy(textp, text, len);
textp[len] = '\0';
return t;
}
/*
* Set the text field to the existing pre-allocated string, either
* taking over or freeing the allocation in the process.
*/
static Token *set_text_free(struct Token *t, char *text, unsigned int len)
{
char *textp;
if (t->len > INLINE_TEXT)
nasm_free(t->text.p.ptr);
nasm_zero(t->text);
t->len = len = tok_check_len(len);
if (len > INLINE_TEXT) {
textp = t->text.p.ptr = text;
} else {
textp = memcpy(t->text.a, text, len);
nasm_free(text);
}
textp[len] = '\0';
return t;
}
/*
* Allocate a new buffer containing a copy of the text field
* of the token.
*/
static char *dup_text(const struct Token *t)
{
size_t size = t->len + 1;
char *p = nasm_malloc(size);
return memcpy(p, tok_text(t), size);
}
/*
* 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.
*
* The "suppressed" flag is used by %exitmacro and %exitrep as well as
* zero-count loops; it indicates that no output should be generated
* the output should be suppressed, but cleanups should still be
* performed.
*/
struct Line {
Line *next;
MMacro *finishes;
Token *first;
struct src_location where; /* Where defined */
bool suppressed;
};
/*
* To handle an arbitrary level of file inclusion, we maintain a
* stack (ie linked list) of these things.
*
* Note: when we issue a message for a continuation line, we want to
* issue it for the actual *start* of the continuation line. This means
* we need to remember how many lines to skip over for the next one.
*/
struct Include {
Include *next;
Cond *conds;
Line *expansion;
FILE *fp;
unsigned char *data; /* Data preloaded */
size_t datasz; /* Total preloaded data */
size_t datapos; /* Index into preloaded data buffer */
uint64_t nolist; /* Listing inhibit counter */
uint64_t noline; /* Line number update inhibit counter */
struct mstk mstk;
struct src_location where; /* Filename and current line number */
int32_t lineinc; /* Increment given by %line */
int32_t lineskip; /* Accounting for passed continuation lines */
};
/*
* File real name hash, so we don't have to re-search the include
* path for every pass (and potentially more than that if a file
* is used more than once.)
*/
struct hash_table FileHash;
/*
* Counters to trap on insane macro recursion or processing.
* Note: for smacros these count *down*, for mmacros they count *up*.
*/
struct deadman {
int64_t total; /* Total number of macros/tokens */
int64_t levels; /* Descent depth across all macros */
bool triggered; /* Already triggered, no need for error msg */
};
static struct deadman smacro_deadman, mmacro_deadman;
/*
* 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.)
*/
enum cond_state {
/*
* 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,
/*
* These states mean that we're not emitting now, and also that
* nothing until %endif will be emitted at all. COND_DONE is
* used when we've had our moment of emission
* and have now started seeing %elifs. COND_NEVER is used when
* the condition construct in question is contained within a
* non-emitting branch of a larger condition construct,
* or if there is an error.
*/
COND_DONE, COND_NEVER
};
struct Cond {
Cond *next;
enum cond_state state;
};
#define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
/*
* These defines are used as the possible return values for do_directive
*/
#define NO_DIRECTIVE_FOUND 0
#define DIRECTIVE_FOUND 1
/*
* Condition codes. Note that we use c_ prefix not C_ because C_ is
* used in nasm.h for the "real" condition codes. At _this_ level,
* we treat CXZ and ECXZ as condition codes, albeit non-invertible
* ones, so we need a different enum...
*/
static const char * const 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", "rcxz", "s", "z"
};
enum pp_conds {
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_RCXZ, c_S, c_Z,
c_none = -1
};
static const enum pp_conds 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, -1, c_NS, c_NZ
};
/*
* Directive names.
*/
/* If this is a an IF, ELIF, ELSE or ENDIF keyword */
static int is_condition(enum preproc_token arg)
{
return PP_IS_COND(arg) || (arg == PP_ELSE) || (arg == PP_ENDIF);
}
static int StackSize = 4;
static const char *StackPointer = "ebp";
static int ArgOffset = 8;
static int LocalOffset = 0;
static Context *cstk;
static Include *istk;
static const struct strlist *ipath_list;
static struct strlist *deplist;
static uint64_t unique; /* unique identifier numbers */
static Line *predef = NULL;
static bool do_predef;
static enum preproc_mode pp_mode;
static uint64_t nested_mac_count;
static uint64_t nested_rep_count;
/*
* The number of macro parameters to allocate space for at a time.
*/
#define PARAM_DELTA 16
/*
* The standard macro set: defined in macros.c in a set of arrays.
* This gives our position in any macro set, while we are processing it.
* The stdmacset is an array of such macro sets.
*/
static macros_t **stdmaclist;
static macros_t *stdmacset[8];
/*
* Map of which %use packages have been loaded
*/
static bool *use_loaded;
/*
* Forward declarations.
*/
static void pp_start_stdmac(void);
static void pp_add_stdmac(macros_t *macros);
static Token *expand_mmac_params(Token * tline);
static Token *expand_smacro(Token * tline);
static Token *expand_smacro_noreset(Token * tline);
static Token *expand_id(Token * tline);
static Context *get_ctx(const char *name, const char **namep);
static Token *make_tok_num(Token *next, int64_t val);
static Token *
make_tok_num_radix(Token *next, int64_t val, char radix, bool uns);
static int64_t get_tok_num(const Token *t, bool *err);
static Token *make_tok_qstr(Token *next, const char *str);
static Token *make_tok_qstr_len(Token *next, const char *str, size_t len);
static Token *make_tok_char(Token *next, char op);
static Token *new_Token(Token * next, enum token_type type,
const char *text, size_t txtlen);
static Token *new_Token_free(Token * next, enum token_type type,
char *text, size_t txtlen);
static Token *dup_Token(Token *next, const Token *src);
static Token *new_White(Token *next);
static Token *free_Token(Token *t);
static Token *do_delete_Token(Token **tp);
#define delete_Token(tp) do_delete_Token(&(tp))
static Token *steal_Token(Token *dst, Token *src);
static const struct use_package *
get_use_pkg(Token *t, const char *dname, const char **name);
static void mark_smac_params(Token *tline, const SMacro *tmpl,
enum token_type type);
/* Safe extraction of token type */
static inline enum token_type tok_type(const Token *x)
{
return x ? x->type : TOKEN_EOS;
}
/* Safe test for token type, false on x == NULL */
static inline bool tok_is(const Token *x, enum token_type t)
{
return tok_type(x) == t;
}
/* True if token is any other kind other that "c", but not NULL */
static inline bool tok_isnt(const Token *x, enum token_type t)
{
return x && x->type != t;
}
/* Whitespace token? */
static inline bool tok_white(const Token *x)
{
return tok_is(x, TOKEN_WHITESPACE);
}
/* A string? */
static inline bool tok_string(const Token *x)
{
return x && (x->type == TOKEN_STR || x->type == TOKEN_INTERNAL_STR);
}
/* A macro identifier? */
static bool tok_macro_id(const Token *x)
{
return x && (x->type == TOKEN_ID || x->type == TOKEN_LOCAL_MACRO);
}
/* A macro or preprocessor function identifier? */
static bool tok_macro_or_func_id(const Token *x)
{
return x && (x->type == TOKEN_ID ||
x->type == TOKEN_PREPROC_ID ||
x->type == TOKEN_LOCAL_MACRO);
}
/* Skip a token, checking for NULL */
static inline Token *skip_tok(Token *x)
{
return x ? x->next : NULL;
}
/* Skip past any whitespace */
static inline Token *skip_white(Token *x)
{
while (tok_white(x))
x = x->next;
return x;
}
/* Skip past a token and any whitespace after it */
static inline Token *skip_tok_white(Token *x)
{
return skip_white(skip_tok(x));
}
/* Delete any whitespace */
static Token *zap_white(Token *x)
{
while (tok_white(x))
x = free_Token(x);
return x;
}
/*
* Unquote a token if it is a string, and set its type to
* TOKEN_INTERNAL_STR.
*/
/*
* Common version for any kind of quoted string; see asm/quote.c for
* information about the arguments.
*/
static const char *unquote_token_anystr(Token *t, uint32_t badctl, char qstart)
{
size_t nlen, olen;
char *p;
if (t->type != TOKEN_STR)
return tok_text(t);
olen = t->len;
p = (olen > INLINE_TEXT) ? t->text.p.ptr : t->text.a;
t->len = nlen = nasm_unquote_anystr(p, NULL, badctl, qstart);
t->type = TOKEN_INTERNAL_STR;
if (olen <= INLINE_TEXT || nlen > INLINE_TEXT)
return p;
nasm_zero(t->text.a);
memcpy(t->text.a, p, nlen);
nasm_free(p);
return t->text.a;
}
/* Unquote any string, can produce any arbitrary binary output */
static const char *unquote_token(Token *t)
{
return unquote_token_anystr(t, 0, STR_NASM);
}
/*
* Same as unquote_token(), but error out if the resulting string
* contains unacceptable control characters.
*/
static const char *unquote_token_cstr(Token *t)
{
return unquote_token_anystr(t, BADCTL, STR_NASM);
}
/*
* Convert a TOKEN_INTERNAL_STR token to a quoted
* TOKEN_STR tokens.
*/
static Token *quote_any_token(Token *t);
static inline unused_func
Token *quote_token(Token *t)
{
if (likely(!tok_is(t, TOKEN_INTERNAL_STR)))
return t;
return quote_any_token(t);
}
/*
* Convert *any* kind of token to a quoted
* TOKEN_STR token.
*/
static Token *quote_any_token(Token *t)
{
size_t len = t->len;
char *p;
p = nasm_quote(tok_text(t), &len);
t->type = TOKEN_STR;
return set_text_free(t, p, len);
}
/*
* In-place reverse a list of tokens.
*/
static Token *reverse_tokens(Token *t)
{
Token *prev = NULL;
Token *next;
while (t) {
next = t->next;
t->next = prev;
prev = t;
t = next;
}
return prev;
}
/*
* getenv() variant operating on an input token
*/
static const char *pp_getenv(const Token *t, bool warn)
{
const char *txt = tok_text(t);
const char *v;
char *buf = NULL;
bool is_string = false;
if (!t)
return NULL;
switch (t->type) {
case TOKEN_ENVIRON:
txt += 2; /* Skip leading %! */
is_string = nasm_isquote(*txt);
break;
case TOKEN_STR:
is_string = true;
break;
case TOKEN_INTERNAL_STR:
case TOKEN_NAKED_STR:
case TOKEN_ID:
is_string = false;
break;
default:
return NULL;
}
if (is_string) {
buf = nasm_strdup(txt);
nasm_unquote_cstr(buf, NULL);
txt = buf;
}
v = getenv(txt);
if (warn && !v) {
nasm_warn(WARN_PP_ENVIRONMENT,
"nonexistent environment variable `%s'", txt);
v = "";
}
if (buf)
nasm_free(buf);
return v;
}
/*
* Free a linked list of tokens.
*/
static void free_tlist(Token *list)
{
while (list)
list = free_Token(list);
}
static void do_delete_tlist(Token **listp)
{
if (listp) {
free_tlist(*listp);
*listp = NULL;
}
}
#define delete_tlist(tp) do_delete_tlist(&(tp))
/*
* Free a line
*/
static void free_line(Line *l)
{
put_mmacro(&l->finishes);
free_tlist(l->first);
nasm_free(l);
}
/*
* Free a linked list of lines.
*/
static void free_llist(Line *list)
{
Line *l, *tmp;
list_for_each_safe(l, tmp, list)
free_line(l);
}
/*
* Free an array of linked lists of tokens
*/
static void free_tlist_array(Token **array, size_t nlists)
{
Token **listp = array;
if (!array)
return;
while (nlists--)
free_tlist(*listp++);
nasm_free(array);
}
static void do_delete_tlist_array(Token ***arrayp, size_t nlist)
{
if (arrayp) {
free_tlist_array(*arrayp, nlist);
*arrayp = NULL;
}
}
#define delete_tlist_array(ap,nl) do_delete_tlist_array(&(ap),nl)
/*
* Duplicate a linked list of tokens.
*/
static Token *dup_tlist(const Token *list, Token ***tailp)
{
Token *newlist = NULL;
Token **tailpp = &newlist;
const Token *t;
list_for_each(t, list) {
Token *nt;
*tailpp = nt = dup_Token(NULL, t);
tailpp = &nt->next;
}
if (tailp) {
**tailp = newlist;
*tailp = tailpp;
}
return newlist;
}
/*
* Duplicate a linked list of tokens with a maximum count
*/
static Token *dup_tlistn(const Token *list, size_t cnt, Token ***tailp)
{
Token *newlist = NULL;
Token **tailpp = &newlist;
const Token *t;
list_for_each(t, list) {
Token *nt;
if (!cnt--)
break;
*tailpp = nt = dup_Token(NULL, t);
tailpp = &nt->next;
}
if (tailp) {
**tailp = newlist;
if (newlist)
*tailp = tailpp;
}
return newlist;
}
/*
* Duplicate a linked list of tokens in reverse order
*/
static Token *dup_tlist_reverse(const Token *list, Token *tail)
{
const Token *t;
list_for_each(t, list)
tail = dup_Token(tail, t);
return tail;
}
/*
* Append an existing tlist to a tail pointer and returns the
* updated tail pointer.
*/
static Token **steal_tlist(Token *tlist, Token **tailp)
{
*tailp = tlist;
if (!tlist)
return tailp;
list_last(tlist, tlist);
return &tlist->next;
}
/*
* Split a tlist in two by setting the next pointer of one object to NULL
* and returning the previous value of the next pointer.
*/
static Token *cut_tlist(Token *t)
{
Token *nt = t->next;
t->next = NULL;
return nt;
}
/*
* Find the pointer to the end of a tlist. If the tlist is empty,
* return the incoming pointer.
*/
static Token **tlist_endptr(Token **tptr)
{
Token *t;
while ((t = *tptr))
tptr = &t->next;
return tptr;
}
/*
* Allocate a new MMacro. This does not claim a refcount; the appropriate
* get_mmacro() calls need to be added.
*/
static MMacro *new_mmacro(void)
{
MMacro *m;
nasm_new(m);
#if DEBUG_MMACRO_REFCOUNT
m->refdbg.next = refdbg_list;
refdbg_list = m;
#endif
return m;
}
/*
* Clear an MMacro after invocation complete
*/
static void clear_mmacro(MMacro *m)
{
nasm_delete(m->params);
nasm_delete(m->iname);
nasm_delete(m->paramlen);
delete_tlist(m->iline);
}
/*
* Free an MMacro
*/
static void free_mmacro(MMacro *m)
{
nasm_assert(m->refcnt == 0);
clear_mmacro(m);
#if !DEBUG_MMACRO_REFCOUNTS
free_tlist(m->dlist);
/* The actual tokens in m->defaults freed by freeing m->dlist */
nasm_delete(m->defaults);
free_llist(m->expansion);
m->next = NULL;
nasm_delete(m->name);
nasm_free(m);
#endif
}
/*
* Unconditionally free a list of MMacros; used on final cleanup
*/
static void free_mmacro_list(MMacro **list_p)
{
MMacro *m, *tmp;
MMacro *list = *list_p;
*list_p = NULL;
if (list)
list->refcnt--;
list_for_each_safe(m, tmp, list) {
if (m->next)
m->next->refcnt--;
if (m->refcnt)
nasm_nonfatal("macro %s: refcnt %lld on free, should be 0\n",
m->name, (long long)m->refcnt);
free_mmacro(m);
}
}
/*
* Clear or free an SMacro
*/
static void free_smacro_members(SMacro *s)
{
if (s->params) {
int i;
for (i = 0; i < s->nparam; i++) {
if (s->params[i].name.len > INLINE_TEXT)
nasm_free(s->params[i].name.text.p.ptr);
if (s->params[i].def)
free_tlist((Token *)s->params[i].def);
}
nasm_free(s->params);
}
nasm_free(s->name);
delete_tlist(s->expansion);
}
static void clear_smacro(SMacro *s)
{
free_smacro_members(s);
/* Wipe everything except the next pointer */
memset(&s->name, 0, sizeof(*s) - offsetof(SMacro, name));
}
/*
* Free an SMacro
*/
static void free_smacro(SMacro *s)
{
free_smacro_members(s);
nasm_free(s);
}
/*
* Free all currently defined macros, and free the hash tables if empty
*/
enum clear_what {
CLEAR_NONE = 0,
CLEAR_DEFINE = 1, /* Clear smacros */
CLEAR_DEFALIAS = 2, /* Clear smacro aliases */
CLEAR_ALLDEFINE = CLEAR_DEFINE|CLEAR_DEFALIAS,
CLEAR_MMACRO = 4,
CLEAR_ALL = CLEAR_ALLDEFINE|CLEAR_MMACRO
};
static void clear_smacro_table(struct hash_table *smt, enum clear_what what)
{
struct hash_iterator it;
const struct hash_node *np;
bool empty = true;
/*
* Walk the hash table and clear out anything we don't want
*/
hash_for_each(smt, it, np) {
SMacro *tmp;
SMacro *s = np->data;
SMacro **head = (SMacro **)&np->data;
list_for_each_safe(s, tmp, s) {
if (what & ((enum clear_what)s->alias + 1)) {
*head = s->next;
free_smacro(s);
} else {
empty = false;
}
}
}
/*
* Free the hash table and keys if and only if it is now empty.
* Note: we cannot free keys even for an empty list above, as that
* mucks up the hash algorithm.
*/
if (empty)
hash_free_all(smt, true);
}
static void free_smacro_table(struct hash_table *smt)
{
clear_smacro_table(smt, CLEAR_ALLDEFINE);
}
static void free_mmacro_table(struct hash_table *mmt)
{
struct hash_iterator it;
const struct hash_node *np;
hash_for_each(mmt, it, np) {
MMacro *m = np->data;
nasm_free((void *)np->key);
free_mmacro_list(&m);
}
hash_free(mmt);
}
static void free_macros(void)
{
check_mmacro_refcounts();
free_smacro_table(&smacros);
free_mmacro_table(&mmacros);
}
/*
* Pop the context stack.
*/
static void ctx_pop(void)
{
Context *c = cstk;
cstk = cstk->next;
free_smacro_table(&c->localmac);
nasm_free((char *)c->name);
nasm_free(c);
}
/*
* Search for a key in the hash index; adding it if necessary
* (in which case we initialize the data pointer to NULL.)
*/
static void **
hash_findi_add(struct hash_table *hash, const char *str)
{
struct hash_insert hi;
void **r;
char *strx;
size_t l = strlen(str) + 1;
r = hash_findib(hash, str, l, &hi);
if (r)
return r;
strx = nasm_malloc(l); /* Use a more efficient allocator here? */
memcpy(strx, str, l);
return hash_add(&hi, strx, NULL);
}
/*
* Like hash_findi, but returns the data element rather than a pointer
* to it. Used only when not adding a new element, hence no third
* argument.
*/
static void *
hash_findix(struct hash_table *hash, const char *str)
{
void **p;
p = hash_findi(hash, str, NULL);
return p ? *p : NULL;
}
static void inject_predefs(void)
{
Line *pd, *l;
/*
* 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.
*/
list_for_each(pd, predef) {
nasm_new(l);
l->next = istk->expansion;
l->first = dup_tlist(pd->first, NULL);
istk->expansion = l;
}
do_predef = false;
}
static uint64_t get_uleb128(const char **pp)
{
const char *p = *pp;
unsigned int shcnt = 0;
uint8_t c;
uint64_t v = 0;
do {
c = *p++;
v += ((uint64_t)(c & 127)) << shcnt;
shcnt += 7;
} while (c & 128);
*pp = p;
return v;
}
static char *line_from_stdmac(void)
{
static const char *stdmacpos = NULL;
static char *stdmacbuf = NULL;
char *line;
size_t len = 0;
if (!stdmacpos || !*stdmacpos) {
macros_t *next = *stdmaclist;
stdmacpos = NULL;
nasm_delete(stdmacbuf);
if (!next) {
if (do_predef)
inject_predefs();
return NULL;
}
*stdmaclist++ = NULL;
if (next->dsize == next->zsize)
stdmacpos = next->zdata; /* Incompressible */
else
stdmacpos = stdmacbuf = uncompress_stdmac(next);
}
/* Length encoded using uleb128 encoding */
len = get_uleb128(&stdmacpos);
line = nasm_malloc(len + 1);
memcpy(line, stdmacpos, len);
line[len] = '\0';
stdmacpos += len;
return line;
}
/*
* Read a line from the a file. Return NULL on end of file.
*/
static char *line_from_file(FILE *f)
{
int c;
unsigned int size, next;
const unsigned int delta = BUFSIZ;
const unsigned int pad = 8;
bool cont = false;
char *buffer, *p;
istk->where.lineno += istk->lineskip + istk->lineinc;
src_set_linnum(istk->where.lineno);
istk->lineskip = 0;
size = delta;
p = buffer = nasm_malloc(size);
do {
c = fgetc(f);
switch (c) {
case EOF:
if (p == buffer) {
nasm_free(buffer);
return NULL;
}
c = 0;
break;
case '\r':
next = fgetc(f);
if (next != '\n')
ungetc(next, f);
if (cont) {
cont = false;
continue;
}
c = 0;
break;
case '\n':
if (cont) {
cont = false;
continue;
}
c = 0;
break;
case 032: /* ^Z = legacy MS-DOS end of file mark */
c = 0;
break;
case '\\':
next = fgetc(f);
ungetc(next, f);
if (next == '\r' || next == '\n') {
cont = true;
istk->lineskip += istk->lineinc;
continue;
}
break;
}
if (p >= (buffer + size - pad)) {
buffer = nasm_realloc(buffer, size + delta);
p = buffer + size - pad;
size += delta;
}
*p++ = c;
} while (c);
return buffer;
}
/*
* Common read routine regardless of source
*/
static char *read_line(void)
{
char *line;
FILE *f = istk->fp;
if (f)
line = line_from_file(f);
else
line = line_from_stdmac();
if (!line)
return NULL;
if (!istk->nolist)
lfmt->line(LIST_READ, istk->where.lineno, line);
return line;
}
/*
* Tokenize 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 *tokenize(const char *line)
{
enum token_type type;
Token *list = NULL;
Token *t, **tail = &list;
while (*line) {
const char *p = line;
const char *ep = NULL; /* End of token, for trimming the end */
size_t toklen;
char firstchar = *p; /* Can be used to override the first char */
if (*p == '%') {
/*
* Preprocessor construct; find the end of the token.
* Classification is handled later, because %{...} can be
* used to create any preprocessor token.
*/
p++;
if (*p == '+' && !nasm_isdigit(p[1])) {
/* Paste token */
p++;
} else if (nasm_isdigit(*p) ||
((*p == '-' || *p == '+') && nasm_isdigit(p[1]))) {
do {
p++;
}
while (nasm_isdigit(*p));
} else if (*p == '{' || *p == '[') {
/* %{...} or %[...] */
char firstchar = *p;
char endchar = *p + 2; /* } or ] */
int lvl = 1;
line += (*p++ == '{'); /* Skip { but not [ (yet) */
while (lvl) {
if (*p == firstchar) {
lvl++;
} else if (*p == endchar) {
lvl--;
} else if (nasm_isquote(*p)) {
p = nasm_skip_string(p);
}
/*
* *p can have been advanced to a null character by
* nasm_skip_string()
*/
if (!*p) {
nasm_warn(firstchar == '}' ?
WARN_PP_OPEN_BRACES : WARN_PP_OPEN_BRACKETS,
"unterminated %%%c...%c construct (missing `%c')",
firstchar, endchar, endchar);
break;
}
p++;
}
ep = lvl ? p : p-1; /* Terminal character not part of token */
} else if (*p == '?') {
/* %? or %?? */
p++;
if (*p == '?')
p++;
} else if (*p == '*' && p[1] == '?') {
/* %*? and %*?? */
p += 2;
if (*p == '?')
p++;
} else if (*p == '!') {
/* Environment variable reference */
p++;
if (nasm_isidchar(*p)) {
do {
p++;
}
while (nasm_isidchar(*p));
} else if (nasm_isquote(*p)) {
p = nasm_skip_string(p);
if (*p)
p++;
else
nasm_nonfatal("unterminated %%! string");
} else {
/* %! without anything else... */
}
} else if (*p == ',') {
/* Conditional comma */
p++;
} else if (nasm_isidchar(*p) ||
(*p == '%' && nasm_isidchar(p[1]))) {
/* Identifier or some sort */
do {
p++;
}
while (nasm_isidchar(*p));
} else if (*p == '%') {
/* %% operator */
p++;
}
if (!ep)
ep = p;
toklen = ep - line;
/* Classify here, to handle %{...} correctly */
if (toklen < 2) {
type = '%'; /* % operator */
if (unlikely(*line == '{')) {
nasm_warn(WARN_PP_EMPTY_BRACES,
"empty %%{} construct expands to the %% operator");
}
} else {
char c0 = line[1];
switch (c0) {
case '+':
type = (toklen == 2) ? TOKEN_PASTE : TOKEN_MMACRO_PARAM;
break;
case '-':
type = TOKEN_MMACRO_PARAM;
break;
case '?':
if (toklen == 2)
type = TOKEN_PREPROC_Q;
else if (toklen == 3 && line[2] == '?')
type = TOKEN_PREPROC_QQ;
else
type = TOKEN_PREPROC_ID;
break;
case '*':
type = TOKEN_OTHER;
if (line[2] == '?') {
if (toklen == 3)
type = TOKEN_PREPROC_SQ;
else if (toklen == 4 && line[3] == '?')
type = TOKEN_PREPROC_SQQ;
}
break;
case '!':
type = (toklen == 2) ? TOKEN_OTHER : TOKEN_ENVIRON;
break;
case '%':
type = (toklen == 2) ? TOKEN_SMOD : TOKEN_LOCAL_SYMBOL;
break;
case '$':
type = (toklen == 2) ? TOKEN_OTHER : TOKEN_LOCAL_MACRO;
break;
case '[':
line += 2; /* Skip %[ */
firstchar = *line; /* Don't clobber */
toklen -= 2;
type = TOKEN_INDIRECT;
break;
case ',':
type = (toklen == 2) ? TOKEN_COND_COMMA : TOKEN_PREPROC_ID;
break;
case '\'':
case '\"':
case '`':
/* %{'string'} */
type = TOKEN_PREPROC_ID;
break;
case ':':
type = TOKEN_MMACRO_PARAM; /* %{:..} */
break;
default:
if (nasm_isdigit(c0))
type = TOKEN_MMACRO_PARAM;
else if (nasm_isidchar(c0) || toklen > 2)
type = TOKEN_PREPROC_ID;
else
type = TOKEN_OTHER;
break;
}
}
} else if (*p == '?' && !nasm_isidchar(p[1])) {
/* ? operator */
type = TOKEN_QMARK;
p++;
} else if (nasm_isidstart(*p) ||
(*p == '$' && nasm_isidchar(p[1]) &&
(p[1] != '$' || nasm_isidchar(p[2])) &&
(!globl.dollarhex || !nasm_isdigit(p[1])))) {
/*
* A regular identifier. This includes keywords which are not
* special to the preprocessor.
*/
type = TOKEN_ID;
while (nasm_isidchar(*++p))
;
} else if (nasm_isquote(*p)) {
/*
* A string token.
*/
char quote = *p;
type = TOKEN_STR;
p = nasm_skip_string(p);
if (*p) {
p++;
} else {
nasm_warn(WARN_PP_OPEN_STRING,
"unterminated string (missing `%c')", quote);
type = TOKEN_ERRSTR;
}
} else if (p[0] == '$' && p[1] == '$') {
type = TOKEN_BASE;
p += 2;
} else if (nasm_isnumstart(*p)) {
bool is_hex = false;
bool is_float = false;
bool has_e = false;
char c;
/*
* A numeric token.
*/
if (*p == '$') {
p++;
is_hex = true;
}
for (;;) {
c = *p++;
if (!is_hex && (c == 'e' || c == 'E')) {
has_e = true;
if (*p == '+' || *p == '-') {
/*
* e can only be followed by +/- if it is either a
* prefixed hex number or a floating-point number
*/
p++;
is_float = true;
}
} else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') {
is_hex = true;
} else if (c == 'P' || c == 'p') {
is_float = true;
if (*p == '+' || *p == '-')
p++;
} else if (nasm_isnumchar(c))
; /* just advance */
else if (c == '.') {
/*
* we need to deal with consequences of the legacy
* parser, like "1.nolist" being two tokens
* (TOKEN_NUM, TOKEN_ID) here; at least give it
* a shot for now. In the future, we probably need
* a flex-based scanner with proper pattern matching
* to do it as well as it can be done. Nothing in
* the world is going to help the person who wants
* 0x123.p16 interpreted as two tokens, though.
*/
const char *r = p;
while (*r == '_')
r++;
if (nasm_isdigit(*r) || (is_hex && nasm_isxdigit(*r)) ||
(!is_hex && (*r == 'e' || *r == 'E')) ||
(*r == 'p' || *r == 'P')) {
p = r;
is_float = true;
} else
break; /* Terminate the token */
} else
break;
}
p--; /* Point to first character beyond number */
if (p == line+1 && *line == '$') {
type = TOKEN_HERE;
} else {
if (has_e && !is_hex) {
/* 1e13 is floating-point, but 1e13h is not */
is_float = true;
}
type = is_float ? TOKEN_FLOAT : TOKEN_NUM;
}
} else if (nasm_isspace(*p)) {
firstchar = ' '; /* Always a single space */
type = TOKEN_WHITESPACE;
p = nasm_skip_spaces(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 = TOKEN_EOS;
} else if (*p == ';') {
type = TOKEN_EOS;
} else {
/*
* Anything else is an operator of some kind. We check
* for all the double-character operators (>>, <<, //,
* %%, <=, >=, ==, !=, <>, &&, ||, ^^) and the triple-
* character operators (<<<, >>>, <=>) but anything
* else is a single-character operator.
*/
type = (unsigned char)*p;
switch (*p++) {
case '>':
if (*p == '>') {
p++;
type = TOKEN_SHR;
if (*p == '>') {
type = TOKEN_SAR;
p++;
}
} else if (*p == '=') {
type = TOKEN_GE;
p++;
}
break;
case '<':
if (*p == '<') {
p++;
type = TOKEN_SHL;
if (*p == '<')
p++;
} else if (*p == '=') {
p++;
type = TOKEN_LE;
if (*p == '>') {
p++;
type = TOKEN_LEG;
}
} else if (*p == '>') {
p++;
type = TOKEN_NE;
}
break;
case '!':
if (*p == '=') {
p++;
type = TOKEN_NE;
}
break;
case '/':
if (*p == '/') {
p++;
type = TOKEN_SDIV;
}
break;
case '=':
if (*p == '=')
p++; /* Still TOKEN_EQ == '=' though */
break;
case '&':
if (*p == '&') {
p++;
type = TOKEN_DBL_AND;
}
break;
case '|':
if (*p == '|') {
p++;
type = TOKEN_DBL_OR;
}
break;
case '^':
if (*p == '^') {
p++;
type = TOKEN_DBL_XOR;
}
break;
default:
break;
}
}
if (type == TOKEN_EOS)
break; /* done with the string... */
if (!ep)
ep = p;
toklen = ep - line;
if (toklen) {
*tail = t = new_Token(NULL, type, line, toklen);
*tok_text_buf(t) = firstchar; /* E.g. %{foo} -> {foo -> %foo */
tail = &t->next;
}
line = p;
}
return list;
}
/*
* Tokens are allocated in blocks to improve speed. Set the blocksize
* to 0 to use regular nasm_malloc(); this is useful for debugging.
*
* alloc_Token() returns a zero-initialized token structure.
*/
#define TOKEN_BLOCKSIZE 0 /* 4096 */ /* Number of tokens, not bytes */
#if TOKEN_BLOCKSIZE
static Token *freeTokens = NULL;
static Token *tokenblocks = NULL;
static Token *alloc_Token(void)
{
Token *t = freeTokens;
if (unlikely(!t)) {
Token *block;
size_t i;
nasm_newn(block, TOKEN_BLOCKSIZE);
/*
* The first entry in each array are a linked list of
* block allocations and is not used for data.
*/
block[0].next = tokenblocks;
block[0].type = TOKEN_BLOCK;
tokenblocks = block;
/*
* Add the rest to the free list
*/
for (i = 2; i < TOKEN_BLOCKSIZE - 1; i++)
block[i].next = &block[i+1];
freeTokens = &block[2];
/*
* Return the topmost usable token
*/
return &block[1];
}
freeTokens = t->next;
t->next = NULL;
return t;
}
static Token *free_Token(Token *t)
{
Token *next;
nasm_assert(t);
nasm_assert(t->type != TOKEN_FREE);
next = t->next;
nasm_zero(*t);
t->type = TOKEN_FREE;
t->next = freeTokens;
freeTokens = t;
return next;
}
static void free_Blocks(void)
{
Token *block, *blocktmp;
list_for_each_safe(block, blocktmp, tokenblocks)
nasm_free(block);
freeTokens = tokenblocks = NULL;
}
#else
static inline Token *alloc_Token(void)
{
Token *t;
nasm_new(t);
return t;
}
static Token *free_Token(Token *t)
{
Token *next = t->next;
nasm_free(t);
return next;
}
static inline void free_Blocks(void)
{
/* Nothing to do */
}
#endif
static Token *do_delete_Token(Token **tp)
{
if (tp)
return *tp = free_Token(*tp);
else
return NULL;
}
/*
* this function creates a new Token and passes a pointer to it
* back to the caller. It sets the type, text, and next pointer elements.
*/
static Token *new_Token(Token * next, enum token_type type,
const char *text, size_t txtlen)
{
Token *t = alloc_Token();
char *textp;
t->next = next;
t->type = type;
if (type == TOKEN_WHITESPACE) {
t->len = 1;
t->text.a[0] = ' ';
} else {
if (text && text[0] && !txtlen)
txtlen = tok_strlen(text);
t->len = tok_check_len(txtlen);
if (text) {
textp = (txtlen > INLINE_TEXT)
? (t->text.p.ptr = nasm_malloc(txtlen+1)) : t->text.a;
memcpy(textp, text, txtlen);
textp[txtlen] = '\0'; /* In case we needed malloc() */
} else {
/*
* Allocate a buffer but do not fill it. The caller
* can fill in text, but must not change the length.
* The filled in text must be exactly txtlen once
* the buffer is filled and before the token is added
* to any line lists.
*/
if (txtlen > INLINE_TEXT)
t->text.p.ptr = nasm_zalloc(txtlen+1);
}
}
return t;
}
/*
* Same as new_Token(), but text belongs to the new token and is
* either taken over or freed. This function MUST be called
* with valid txt and txtlen, unlike new_Token().
*/
static Token *new_Token_free(Token * next, enum token_type type,
char *text, size_t txtlen)
{
Token *t = alloc_Token();
t->next = next;
t->type = type;
t->len = tok_check_len(txtlen);
if (txtlen <= INLINE_TEXT) {
memcpy(t->text.a, text, txtlen);
nasm_free(text);
} else {
t->text.p.ptr = text;
}
return t;
}
static Token *dup_Token(Token *next, const Token *src)
{
Token *t;
if (unlikely(!src))
return NULL;
t = alloc_Token();
memcpy(t, src, sizeof *src);
t->next = next;
if (t->len > INLINE_TEXT) {
t->text.p.ptr = nasm_malloc(t->len + 1);
memcpy(t->text.p.ptr, src->text.p.ptr, t->len+1);
}
return t;
}
static Token *new_White(Token *next)
{
Token *t = alloc_Token();
t->next = next;
t->type = TOKEN_WHITESPACE;
t->len = 1;
t->text.a[0] = ' ';
return t;
}
/*
* This *transfers* the content from one token to another, leaving the
* next pointer of the latter intact. Unlike dup_Token(), the old
* token is destroyed, except for its next pointer, and the text
* pointer allocation, if any, is simply transferred.
*/
static Token *steal_Token(Token *dst, Token *src)
{
/* Delete any previous text string allocation */
if (unlikely(dst->len > INLINE_TEXT))
nasm_free(dst->text.p.ptr);
/* Overwrite everything except the next pointers */
memcpy((char *)dst + sizeof(Token *), (char *)src + sizeof(Token *),
sizeof(Token) - sizeof(Token *));
/* Clear the donor token */
memset((char *)src + sizeof(Token *), 0, sizeof(Token) - sizeof(Token *));
return dst;
}
/*
* Convert a line of tokens back into text. This modifies the list
* by expanding environment variables.
*
* If expand_locals is not zero, identifiers of the form "%$*xxx"
* are also transformed into ..@ctxnum.xxx
*/
static char *detoken(Token * tlist, bool expand_locals)
{
Token *t;
char *line, *p;
int len = 0;
list_for_each(t, tlist) {
switch (t->type) {
case TOKEN_ENVIRON:
{
const char *v = pp_getenv(t, true);
set_text(t, v, tok_strlen(v));
t->type = TOKEN_NAKED_STR;
break;
}
case TOKEN_LOCAL_MACRO:
case TOKEN_LOCAL_SYMBOL:
if (expand_locals) {
const char *q;
char *p;
Context *ctx = get_ctx(tok_text(t), &q);
if (ctx) {
p = nasm_asprintf("..@%"PRIu64".%s", ctx->number, q);
set_text_free(t, p, nasm_last_string_len());
t->type = TOKEN_ID;
}
}
break;
case TOKEN_INDIRECT:
/*
* This won't happen in when emitting to the assembler,
* but can happen when emitting output for some of the
* list options. The token string doesn't actually include
* the brackets in this case.
*/
len += 3; /* %[] */
break;
case TOKEN_FREE:
panic();
default:
break; /* No modifications */
}
if (debug_level(2)) {
unsigned int t_len = t->len;
unsigned int s_len = tok_strlen(tok_text(t));
if (t_len != s_len) {
nasm_panic("assertion failed: token \"%s\" type %u len %u has t->len %u\n",
tok_text(t), t->type, s_len, t_len);
t->len = s_len;
}
}
len += t->len;
}
p = line = nasm_malloc(len + 1);
list_for_each(t, tlist) {
switch (t->type) {
case TOKEN_INDIRECT:
*p++ = '%';
*p++ = '[';
p = mempcpy(p, tok_text(t), t->len);
*p++ = ']';
break;
default:
p = mempcpy(p, tok_text(t), t->len);
}
}
*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.
*
* FIX: This really needs to be unified with stdscan.
*/
struct ppscan {
Token *tptr;
int ntokens;
};
static int ppscan(void *private_data, struct tokenval *tokval)
{
struct ppscan *pps = private_data;
Token *tline;
const char *txt;
do {
if (pps->ntokens && (tline = pps->tptr)) {
pps->ntokens--;
pps->tptr = tline->next;
} else {
pps->tptr = NULL;
pps->ntokens = 0;
return tokval->t_type = TOKEN_EOS;
}
} while (tline->type == TOKEN_WHITESPACE);
txt = tok_text(tline);
tokval->t_start = txt;
tokval->t_len = tline->len;
tokval->t_charptr = (char *)txt; /* Fix this */
switch (tline->type) {
default:
break;
return tokval->t_type = tline->type;
case TOKEN_ID:
if (txt[0] == '$') {
/* Escaped symbol */
tokval->t_charptr++;
} else {
/* This could be an assembler keyword */
return nasm_token_hash(txt, tokval);
}
break;
case TOKEN_NUM:
{
bool rn_error;
if (*txt == '$')
warn_dollar_hex();
tokval->t_integer = readnum(txt, &rn_error);
if (rn_error)
return tokval->t_type = TOKEN_ERRNUM;
else
return tokval->t_type = TOKEN_NUM;
}
case TOKEN_STR:
tokval->t_charptr = (char *)unquote_token(tline);
/* fall through */
case TOKEN_INTERNAL_STR:
case TOKEN_NAKED_STR:
tokval->t_inttwo = tline->len;
return tokval->t_type = TOKEN_STR;
}
return tokval->t_type = tline->type;
}
/*
* 1. An expression (true if nonzero 0)
* 2. The keywords true, on, yes for true
* 3. The keywords false, off, no for false
* 4. An empty line, for true
*
* On error, return defval (usually the previous value)
*/
static bool pp_get_boolean_option(Token *tline, bool defval)
{
static const char * const noyes[] = {
"no", "yes",
"false", "true",
"off", "on"
};
struct ppscan pps;
struct tokenval tokval;
expr *evalresult;
tline = skip_white(tline);
if (!tline)
return true;
if (tline->type == TOKEN_ID) {
size_t i;
const char *txt = tok_text(tline);
for (i = 0; i < ARRAY_SIZE(noyes); i++)
if (!nasm_stricmp(txt, noyes[i]))
return i & 1;
}
pps.tptr = NULL;
pps.tptr = tline;
pps.ntokens = -1;
tokval.t_type = TOKEN_INVALID;
evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
if (!evalresult)
return true;
if (tokval.t_type) {
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after expression ignored");
}
if (!is_really_simple(evalresult)) {
nasm_nonfatal("boolean flag expression must be a constant");
return defval;
}
return reloc_value(evalresult) != 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(const char *p, const char *q, bool casesense)
{
return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
}
/*
* 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 mmemcmp(const char *p, const char *q, size_t l, bool casesense)
{
return casesense ? memcmp(p, q, l) : nasm_memicmp(p, q, l);
}
/*
* 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 "namep" is non-NULL, set it to the pointer to the macro name
* tail, i.e. the part beyond %$...
*/
static Context *get_ctx(const char *name, const char **namep)
{
Context *ctx;
int i;
if (namep)
*namep = name;
if (!name || name[0] != '%' || name[1] != '$')
return NULL;
if (!cstk) {
nasm_nonfatal("`%s': context stack is empty", name);
return NULL;
}
name += 2;
ctx = cstk;
i = 0;
while (ctx && *name == '$') {
name++;
i++;
ctx = ctx->next;
}
if (!ctx) {
nasm_nonfatal("`%s': context stack is only"
" %d level%s deep", name, i, (i == 1 ? "" : "s"));
return NULL;
}
if (namep)
*namep = name;
return ctx;
}
/*
* 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.
*
* Note: for INC_PROBE the function returns NULL at all times;
* instead look for a filename in *slpath.
*/
enum incopen_mode {
INC_OPTIONAL = 0,
INC_NEEDED = 1, /* File must exist */
INC_REQUIRED = 2, /* File must exist, but only open once/pass */
INC_PROBE = 4, /* Existence probe (don't open the file) */
INC_EXACT = 8 /* Exact filename match only (no path search) */
};
/* This is conducts a full pathname search */
static FILE *inc_fopen_search(const char *file,
char **slpath,
enum incopen_mode *omp,
enum file_flags fmode)
{
const struct strlist_entry *ip;
FILE *fp;
const char *prefix = "";
char *sp;
bool found;
enum incopen_mode omode = *omp;
ip = omode & INC_EXACT ? NULL : strlist_head(ipath_list);
while (1) {
sp = nasm_catfile(prefix, file);
if (omode & INC_PROBE) {
fp = NULL;
found = nasm_file_exists(sp);
} else {
fp = nasm_open_read(sp, fmode);
found = (fp != NULL);
}
if (found) {
*slpath = sp;
if (!prefix[0])
*omp |= INC_EXACT;
return fp;
}
nasm_free(sp);
if (!ip) {
*slpath = NULL;
return NULL;
}
prefix = ip->str;
ip = ip->next;
}
}
/*
* Open a file, or test for the presence of one (depending on omode),
* considering the include path.
*/
struct file_hash_entry {
const char *path;
struct file_hash_entry *full; /* Hash entry for the full path */
int64_t include_pass; /* Pass in which last included (for %require) */
enum incopen_mode omode; /* Flags */
};
static FILE *inc_fopen(const char *file,
struct strlist *dhead,
const struct file_hash_entry **found_fhe,
enum incopen_mode omode,
enum file_flags fmode)
{
struct file_hash_entry **fhep;
struct file_hash_entry *fhe = NULL;
struct hash_insert hi;
const char *path = NULL;
FILE *fp = NULL;
const int64_t pass = pass_count();
bool skip_open = !!(omode & INC_PROBE);
fhep = (struct file_hash_entry **)hash_find(&FileHash, file, &hi);
if (fhep) {
fhe = *fhep;
path = fhe->path;
if ((omode ^ fhe->omode) & INC_EXACT) {
if (omode & INC_EXACT)
path = NULL; /* Entry found, but it is non-exact */
else if (!path)
fhe = NULL; /* No exact entry found, but maybe searchable */
}
}
if (!fhe) {
/* Need to do the actual path search */
char *pptr;
fp = inc_fopen_search(file, &pptr, &omode, fmode);
path = pptr;
/* Positive or negative result */
nasm_new(fhe);
fhe->path = path;
fhe->full = fhe; /* It is *possible*... */
fhe->omode = omode & INC_EXACT;
/*
* Don't cache a negative result if INC_EXACT is specified
* (used by %iffile). In the future consider making it
* possible to distinguish, but for now don't worry about
* it...
*/
if (fhep) {
nasm_free(*fhep);
*fhep = fhe;
} else {
hash_add(&hi, nasm_strdup(file), fhe);
}
/*
* Add a hash entry for the canonical path if there isn't one
* already. Try to get the unique name from the OS best we can.
* Note that ->path and ->full->path can be different, and that
* is okay (we don't want to print out a full canonical path
* in messages, for example.)
*/
if (path) {
char *fullpath = nasm_realpath(path);
if (!strcmp(file, fullpath)) {
nasm_free(fullpath);
} else {
struct file_hash_entry **fullp, *full;
fullp = (struct file_hash_entry **)
hash_find(&FileHash, fullpath, &hi);
if (fullp) {
full = *fullp;
nasm_free(fullpath);
} else {
nasm_new(full);
full->path = fullpath;
full->full = full;
full->omode = INC_EXACT;
hash_add(&hi, full->path, full);
}
fhe->full = full;
}
}
}
if (dhead) {
/*
* This file could have previously probed for but never added;
* in that case it may be necessary to try to re-add it here.
*
* This could be fixed by merging the file hash and dependency
* array at some point...
*/
strlist_add(dhead, path ? path : file);
}
if (path) {
skip_open |=
((omode | fhe->full->omode) & INC_REQUIRED) &&
(fhe->full->include_pass >= pass);
if (!skip_open) {
fp = nasm_open_read(path, fmode);
if (fp)
fhe->full->include_pass = pass;
}
}
if (!fp && !skip_open && (omode & INC_NEEDED)) {
if (!path)
errno = ENOENT;
nasm_nonfatal("unable to open include file `%s': %s",
file, strerror(errno));
}
if (found_fhe)
*found_fhe = path ? fhe : NULL;
return fp;
}
/*
* Opens an include or input file. Public version, for use by modules
* that get a file:lineno pair and need to look at the file again
* (e.g. the CodeView debug backend). Returns NULL on failure.
*/
FILE *pp_input_fopen(const char *filename, enum file_flags mode)
{
return inc_fopen(filename, NULL, NULL, INC_OPTIONAL, mode);
}
/*
* Expand a token list that is expected to contain a filename string.
* Returns a new token containing a TOK_INTERNAL_STR with the given
* filename, or NULL on error. If the argument "*otp" is set, set
* that to point to the actual quoted string token.
*/
static Token *tlist_filename(Token **tp, Token **otp, const char *dname)
{
Token *t;
*tp = t = expand_smacro_noreset(*tp);
t = skip_white(t);
if (!tok_string(t)) {
if (otp)
*otp = NULL;
nasm_nonfatal("`%s' expects a file name", dname);
return NULL;
}
if (skip_white(t->next)) {
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after `%s' ignored", dname);
}
if (otp)
*otp = t;
t = dup_Token(NULL, t);
unquote_token_cstr(t);
return t;
}
/*
* This implements the %pathsearch directive and %pathsearch() function.
* Returns a new token.
*/
static Token *pp_do_pathsearch(Token **tp, const char *dname)
{
const struct file_hash_entry *fhe;
Token *t, *ot;
t = tlist_filename(tp, &ot, dname);
if (!t)
return NULL;
inc_fopen(tok_text(t), NULL, &fhe, INC_PROBE, NF_BINARY);
if (fhe) {
delete_Token(t);
return make_tok_qstr(NULL, fhe->path);
} else {
return steal_Token(t, ot);
}
}
/*
* This implements the %depend directive and the %depend() function.
* It returns a stolen copy of the original string token after skipping
* leading spaces, or NULL on error.
* Returns a new token.
*/
static Token *pp_do_depend(Token **tp, const char *dname)
{
Token *t, *ot;
t = tlist_filename(tp, &ot, dname);
if (!t)
return NULL;
strlist_add(deplist, tok_text(t));
return steal_Token(t, ot);
}
/*
* 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'.
*/
static bool
smacro_defined(Context *ctx, const char *name, int nparam, SMacro **defn,
bool nocase, bool find_alias)
{
struct hash_table *smtbl;
SMacro *m;
smtbl = ctx ? &ctx->localmac : &smacros;
restart:
m = (SMacro *) hash_findix(smtbl, name);
while (m) {
if (!mstrcmp(m->name, name, m->casesense && nocase) &&
(nparam <= 0 || m->nparam == 0 ||
(nparam >= m->nparam_min &&
(m->varadic || nparam <= m->nparam)))) {
if (m->alias && !find_alias) {
if (!ppconf.noaliases) {
name = tok_text(m->expansion);
goto restart;
} else {
continue;
}
}
if (defn)
*defn = m;
return true;
}
m = m->next;
}
return false;
}
/* param should be a natural number [0; INT_MAX] */
static int read_param_count(const char *str)
{
int result;
bool err;
result = readnum(str, &err);
if (result < 0 || result > INT_MAX) {
result = 0;
nasm_nonfatal("parameter count `%s' is out of bounds [%d; %d]",
str, 0, INT_MAX);
} else if (err)
nasm_nonfatal("unable to parse parameter count `%s'", str);
return result;
}
/*
* 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.
*
* Note that we need space in the params array for parameter 0 being
* a possible captured label as well as the final NULL.
*
* Returns a pointer to the pointer to a terminal comma if present;
* used to drop an empty terminal argument for legacy reasons.
*/
static Token **count_mmac_params(Token *tline, int *nparamp, Token ***paramsp)
{
int paramsize;
int nparam = 0;
Token *t;
Token **comma = NULL, **maybe_comma = NULL;
Token **params;
paramsize = PARAM_DELTA;
nasm_newn(params, paramsize);
t = skip_white(tline);
if (t) {
while (true) {
/* Need two slots for captured label and NULL */
if (unlikely(nparam+2 >= paramsize)) {
paramsize += PARAM_DELTA;
params = nasm_realloc(params, sizeof(*params) * paramsize);
}
params[++nparam] = t;
if (tok_is(t, '{')) {
int brace = 1;
comma = NULL; /* Non-empty parameter */
while (brace && (t = t->next)) {
brace += tok_is(t, '{');
brace -= tok_is(t, '}');
}
if (t) {
/*
* Now we've found the closing brace, look further
* for the comma.
*/
t = skip_white(t->next);
if (tok_isnt(t, ','))
nasm_nonfatal("braces do not enclose all of macro parameter");
} else {
nasm_nonfatal("expecting closing brace in macro parameter");
}
}
if (!t)
break; /* End of string, no comma */
/* Advance to the next comma */
maybe_comma = &t->next;
while (tok_isnt(t, ',')) {
if (!tok_white(t))
comma = NULL; /* Non-empty parameter */
maybe_comma = &t->next;
t = t->next;
}
if (!t)
break; /* End of string, no comma */
comma = maybe_comma; /* Point to comma pointer */
t = skip_white(t->next); /* Eat the comma and whitespace */
}
}
params[nparam+1] = NULL;
*paramsp = params;
*nparamp = nparam;
return comma;
}
/* Check to see if a string is a valid preprocessor directive */
/* This requires that the caller has checked dname[0] == '%' */
static inline enum preproc_token pp_get_nasm_directive(const char *dname)
{
/*
* For it to be a directive, the second character has to be an
* ASCII letter; this is a very quick and dirty test for that;
* all other cases will get rejected by the token hash.
*/
if (likely((uint8_t)((dname[1] & ~0x20) - 'A') <= 'Z'))
return pp_token_hash(dname);
return PP_invalid;
}
static inline enum preproc_token pp_get_tasm_directive(const char *dname)
{
if (likely(!(ppopt & PP_TASM)))
return PP_invalid;
/*
* Directive in TASM mode. Again, must begin with a letter.
*/
if ((uint8_t)((dname[0] & ~0x20) - 'A') <= 'Z')
return pp_tasm_token_hash(dname);
return PP_invalid;
}
static enum preproc_token pp_get_directive(const char *dname)
{
if (dname[0] == '%')
return pp_get_nasm_directive(dname);
else
return pp_get_tasm_directive(dname);
}
static bool is_directive(const char *dname)
{
char *p;
const char *q;
bool j;
dname = nasm_skip_spaces(dname);
if (*dname == '[') {
dname = nasm_skip_spaces(dname+1);
} else {
if (*dname == '%')
return pp_get_nasm_directive(dname) != PP_invalid;
if (pp_get_tasm_directive(dname) != PP_invalid)
return true;
}
q = nasm_skip_word(dname);
p = nasm_strndup(dname, q-dname);
j = directive_valid(p);
nasm_free(p);
return j;
}
/*
* Determine whether one of the various `if' conditions is true or
* not.
*
* We must free the tline we get passed.
*/
static enum cond_state
if_condition(Token * tline, enum preproc_token ct, const char *dname)
{
bool j;
Token *t, *tt, *origline;
struct ppscan pps;
struct tokenval tokval;
expr *evalresult;
enum token_type needtype;
bool casesense = true;
enum preproc_token cond = PP_COND(ct);
origline = tline;
switch (cond) {
case PP_IFCTX:
j = false; /* have we matched yet? */
while (true) {
tline = skip_white(tline);
if (!tline)
break;
if (tline->type != TOKEN_ID) {
nasm_nonfatal("`%s' expects context identifiers",
dname);
goto fail;
}
if (cstk && cstk->name && !nasm_stricmp(tok_text(tline), cstk->name))
j = true;
tline = tline->next;
}
break;
case PP_IFDEF:
case PP_IFDEFALIAS:
{
bool alias = cond == PP_IFDEFALIAS;
SMacro *smac;
Context *ctx;
const char *mname;
j = false; /* have we matched yet? */
while (tline) {
tline = skip_white(tline);
if (!tok_macro_or_func_id(tline)) {
nasm_nonfatal("`%s' expects macro identifiers",
dname);
goto fail;
}
mname = tok_text(tline);
ctx = get_ctx(mname, &mname);
if (smacro_defined(ctx, mname, -1, &smac, true, alias) && smac
&& smac->alias == alias) {
j = true;
break;
}
tline = tline->next;
}
break;
}
case PP_IFDIFI:
/*
* %ifdifi doesn't actually exist; it ignores its argument and is
* always false. This exists solely to stub out the corresponding
* TASM directive.
*/
j = false;
goto fail;
case PP_IFDIRECTIVE:
tline = skip_white(expand_smacro(tline));
j = false;
if (tline)
j = is_directive(unquote_token(tline));
break;
case PP_IFENV:
tline = expand_smacro(tline);
j = false; /* have we matched yet? */
while (tline) {
tline = skip_white(tline);
if (!tline || (tline->type != TOKEN_ID &&
tline->type != TOKEN_STR &&
tline->type != TOKEN_INTERNAL_STR &&
tline->type != TOKEN_ENVIRON)) {
nasm_nonfatal("`%s' expects environment variable names",
dname);
goto fail;
}
j |= !!pp_getenv(tline, false);
tline = tline->next;
}
break;
case PP_IFFILE:
{
const struct file_hash_entry *fhe;
t = tlist_filename(&origline, NULL, dname);
if (!t)
goto fail;
inc_fopen(tok_text(t), NULL, &fhe, INC_PROBE|INC_EXACT, NF_BINARY);
j = fhe && (fhe->omode & INC_EXACT);
delete_Token(t);
break;
}
case PP_IFIDNI:
casesense = false;
/* fall through */
case PP_IFIDN:
tline = expand_smacro(tline);
t = tt = tline;
while (tok_isnt(tt, ','))
tt = tt->next;
if (!tt) {
nasm_nonfatal("`%s' expects two comma-separated arguments",
dname);
goto fail;
}
tt = tt->next;
j = true; /* assume equality unless proved not */
while (tok_isnt(t, ',') && tt) {
unsigned int l1, l2;
const char *t1, *t2;
if (tok_is(tt, ',')) {
nasm_nonfatal("`%s': more than one comma on line",
dname);
goto fail;
}
if (t->type == TOKEN_WHITESPACE) {
t = t->next;
continue;
}
if (tt->type == TOKEN_WHITESPACE) {
tt = tt->next;
continue;
}
if (tt->type != t->type) {
j = false; /* found mismatching tokens */
break;
}
t1 = unquote_token(t);
t2 = unquote_token(tt);
l1 = t->len;
l2 = tt->len;
if (l1 != l2 || mmemcmp(t1, t2, l1, casesense)) {
j = false;
break;
}
t = t->next;
tt = tt->next;
}
if (!tok_is(t, ',') || tt)
j = false; /* trailing gunk on one end or other */
break;
case PP_IFMACRO:
{
bool found = false;
MMacro searching, *mmac;
tline = skip_white(tline);
tline = expand_id(tline);
if (!tok_is(tline, TOKEN_ID)) {
nasm_nonfatal("`%s' expects a macro name", dname);
goto fail;
}
nasm_zero(searching);
searching.name = dup_text(tline);
searching.casesense = true;
searching.nparam_min = 0;
searching.nparam_max = INT_MAX;
tline = expand_smacro(tline->next);
tline = skip_white(tline);
if (!tline) {
} else if (!tok_is(tline, TOKEN_NUM)) {
nasm_nonfatal("`%s' expects a parameter count or nothing",
dname);
} else {
searching.nparam_min = searching.nparam_max =
read_param_count(tok_text(tline));
}
if (tline && tok_is(tline->next, '-')) {
tline = tline->next->next;
if (tok_is(tline, '*'))
searching.nparam_max = INT_MAX;
else if (!tok_is(tline, TOKEN_NUM))
nasm_nonfatal("`%s' expects a parameter count after `-'",
dname);
else {
searching.nparam_max = read_param_count(tok_text(tline));
if (searching.nparam_min > searching.nparam_max) {
nasm_nonfatal("minimum parameter count exceeds maximum");
searching.nparam_max = searching.nparam_min;
}
}
}
if (tline && tok_is(tline->next, '+')) {
tline = tline->next;
searching.plus = true;
}
mmac = (MMacro *) hash_findix(&mmacros, 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;
}
if (tline && tline->next) {
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after `%s' ignored", dname);
}
nasm_free(searching.name);
j = found;
break;
}
case PP_IFID:
needtype = TOKEN_ID;
goto iftype;
case PP_IFNUM:
needtype = TOKEN_NUM;
goto iftype;
case PP_IFSTR:
needtype = TOKEN_STR;
goto iftype;
iftype:
t = tline = expand_smacro(tline);
while (tok_white(t) ||
(needtype == TOKEN_NUM && (tok_is(t, '-') || tok_is(t, '+'))))
t = t->next;
j = tok_is(t, needtype);
break;
case PP_IFTOKEN:
tline = expand_smacro(tline);
t = skip_white(tline);
j = false;
if (t) {
t = skip_white(t->next); /* Skip the actual token + whitespace */
j = !t;
}
break;
case PP_IFEMPTY:
tline = expand_smacro(tline);
t = skip_white(tline);
j = !t; /* Should be empty */
break;
case PP_IF:
pps.tptr = tline = expand_smacro(tline);
pps.ntokens = -1;
tokval.t_type = TOKEN_INVALID;
evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
if (!evalresult)
return -1;
if (tokval.t_type) {
nasm_warn(WARN_PP_TRAILING, "trailing garbage after expression ignored");
}
if (!is_simple(evalresult)) {
nasm_nonfatal("non-constant value given to `%s'",
dname);
goto fail;
}
j = reloc_value(evalresult) != 0;
break;
case PP_IFUSING:
case PP_IFUSABLE:
{
const struct use_package *pkg;
const char *name;
pkg = get_use_pkg(tline, dname, &name);
if (!name)
goto fail;
j = pkg && ((cond == PP_IFUSABLE) | use_loaded[pkg->index]);
break;
}
default:
nasm_nonfatal("unknown preprocessor directive `%s'", dname);
goto fail;
}
delete_tlist(origline);
return (j ^ PP_COND_NEGATIVE(ct)) ? COND_IF_TRUE : COND_IF_FALSE;
fail:
delete_tlist(origline);
return COND_NEVER;
}
/*
* Default smacro expansion routine: just returns a copy of the
* expansion list.
*/
static Token *
smacro_expand_default(const SMacro *s, Token **params, int nparams)
{
(void)params;
(void)nparams;
return dup_tlist(s->expansion, NULL);
}
/*
* Emit a macro definition or undef to the listing file or debug format
* if desired. This is similar to detoken(), but it handles the
* reverse expansion list, does not expand %! or local variable
* tokens, and does some special handling for macro parameters.
*/
static void
list_smacro_def(enum preproc_token op, const Context *ctx, const SMacro *m)
{
Token *t;
size_t namelen, size;
char *def, *p, *end_spec;
char *context_prefix = NULL;
size_t context_len;
namelen = strlen(m->name);
size = namelen + 2; /* Include room for space after name + NUL */
if (ctx) {
int context_depth = cstk->depth - ctx->depth + 1;
context_prefix =
nasm_asprintf("[%s::%"PRIu64"] %%%-*s",
ctx->name ? ctx->name : "",
ctx->number, context_depth, "");
context_len = nasm_last_string_len();
memset(context_prefix + context_len - context_depth,
'$', context_depth);
size += context_len;
}
list_for_each(t, m->expansion)
size += t->len;
if (m->nparam) {
/*
* Space for ( and either , or ) around each
* parameter, plus up to 5 flags + /ux
*/
int i;
size += 1 + 8 * m->nparam;
for (i = 0; i < m->nparam; i++)
size += m->params[i].name.len;
}
def = nasm_malloc(size);
p = def+size;
*--p = '\0';
list_for_each(t, m->expansion) {
p -= t->len;
memcpy(p, tok_text(t), t->len);
}
*--p = ' ';
end_spec = p; /* Truncate here for macro def only */
if (m->nparam) {
int i;
*--p = ')';
for (i = m->nparam-1; i >= 0; i--) {
enum sparmflags flags = m->params[i].flags;
bool slash = false;
if (m->params[i].radix) {
*--p = m->params[i].radix;
slash = true;
}
if (flags & SPARM_UNSIGNED) {
*--p = 'u';
slash = true;
}
if (slash)
*--p = '/';
if (flags & (SPARM_GREEDY|SPARM_VARADIC))
*--p = '+';
p -= m->params[i].name.len;
memcpy(p, tok_text(&m->params[i].name), m->params[i].name.len);
if (flags & SPARM_NOSTRIP)
*--p = '!';
if (flags & SPARM_STR) {
*--p = '&';
if (flags & SPARM_CONDQUOTE)
*--p = '&';
}
if (flags & SPARM_EVAL)
*--p = '=';
*--p = ',';
}
*p = '('; /* First parameter starts with ( not , */
}
p -= namelen;
memcpy(p, m->name, namelen);
if (context_prefix) {
p -= context_len;
memcpy(p, context_prefix, context_len);
nasm_free(context_prefix);
}
if (ppdbg & PDBG_LIST_SMACROS)
nasm_listmsg("%s %s", pp_directives[op], p);
if (ppdbg & PDBG_SMACROS) {
bool define = !(op == PP_UNDEF || op == PP_UNDEFALIAS);
if (!define)
*end_spec = '\0'; /* Remove the expansion (for list file only) */
dfmt->debug_smacros(define, p);
}
nasm_free(def);
}
/*
* Parse smacro arguments, return argument count. If the tmpl argument
* is set, set the nparam, varadic and params field in the template.
* The varadic field is not used by define_smacro(), but is provided
* in case the caller wants it for other purposes.
*
* *tpp is updated to point to the pointer to the first token after the
* prototype.
*
* The text values from any argument tokens are "stolen" and the
* corresponding text fields set to NULL.
*
* Note that the user can't define a true varadic macro; doing so
* would be meaningless. The true varadic macros are only used for
* internal "magic macro" functions.
*/
static int parse_smacro_template(Token ***tpp, SMacro *tmpl)
{
int nparam = 0;
enum sparmflags flags;
struct smac_param *params = NULL;
bool err, done;
bool greedy = false;
bool parsing_radix;
char radix;
Token **tn = *tpp;
Token *t = *tn;
Token *name;
/*
* DO NOT skip whitespace here, or we won't be able to distinguish:
*
* %define foo (a,b) ; no arguments, (a,b) is the expansion
* %define bar(a,b) ; two arguments, empty expansion
*
* This ambiguity was inherited from C.
*/
if (!tok_is(t, '('))
goto finish;
if (tmpl) {
Token *tx = t;
Token **txpp = &tx;
int sparam;
/* Count parameters first */
sparam = parse_smacro_template(&txpp, NULL);
if (!sparam)
goto finish; /* No parameters, we're done */
nasm_newn(params, sparam);
}
/* Skip leading paren */
tn = &t->next;
t = *tn;
name = NULL;
flags = 0;
radix = 0;
parsing_radix = false;
err = done = false;
while (!done) {
if (!t) {
if (name || flags)
nasm_nonfatal("`)' expected to terminate macro template");
else
nasm_nonfatal("parameter identifier expected");
break;
}
switch (t->type) {
case TOKEN_ID:
if (parsing_radix) {
const char *cp;
for (cp = tok_text(t); cp && *cp; cp++) {
switch (*cp | 0x20) {
case 'b': case 'y':
case 'd': case 't':
case 'o': case 'q':
case 'h': case 'x':
radix = *cp;
break;
case 's':
flags &= ~SPARM_UNSIGNED;
break;
case 'u':
flags |= SPARM_UNSIGNED;
break;
default:
nasm_nonfatal("invalid radix specifier `/%s'",
tok_text(t));
cp = NULL;
break;
}
}
} else {
if (name)
goto bad;
name = t;
}
break;
case '=':
flags |= SPARM_EVAL;
break;
case '&':
flags |= SPARM_STR;
break;
case TOKEN_DBL_AND:
flags |= SPARM_STR|SPARM_CONDQUOTE;
break;
case '!':
flags |= SPARM_NOSTRIP;
break;
case '+':
flags |= SPARM_GREEDY|SPARM_OPTIONAL;
greedy = true;
break;
case '/':
if (!(flags & SPARM_EVAL))
nasm_nonfatal("radix specifier for parameter without `='");
parsing_radix = true;
break;
case ',':
if (greedy)
nasm_nonfatal("greedy parameter must be last");
goto end_param;
case ')':
done = true;
goto end_param;
end_param:
if (params) {
if (name)
steal_Token(&params[nparam].name, name);
params[nparam].flags = flags;
params[nparam].radix = radix;
}
nparam++;
name = NULL;
flags = 0;
parsing_radix = false;
radix = 0;
break;
case TOKEN_WHITESPACE:
break;
default:
bad:
if (!err) {
nasm_nonfatal("garbage `%s' in macro parameter list",
tok_text(t));
err = true;
}
break;
}
tn = &t->next;
t = *tn;
}
finish:
while (t && t->type == TOKEN_WHITESPACE) {
tn = &t->next;
t = t->next;
}
*tpp = tn;
if (tmpl) {
tmpl->nparam = nparam;
tmpl->varadic = greedy;
tmpl->params = params;
}
return nparam;
}
/*
* Common code for defining an smacro. The tmpl argument, if not NULL,
* contains any macro parameters that aren't explicit arguments;
* those are the more uncommon macro variants.
*/
static SMacro *define_smacro(const char *mname, bool casesense,
Token *expansion, SMacro *tmpl)
{
SMacro *smac, **smhead;
struct hash_table *smtbl;
Context *ctx;
bool defining_alias = false;
int nparam = 0;
bool defined;
if (tmpl) {
defining_alias = tmpl->alias;
nparam = tmpl->nparam;
if (nparam && !defining_alias)
mark_smac_params(expansion, tmpl, 0);
}
ctx = get_ctx(mname, &mname);
defined = smacro_defined(ctx, mname, nparam, &smac, casesense, true);
if (defined) {
if (smac->alias) {
if (smac->in_progress) {
nasm_nonfatal("macro alias loop");
goto fail;
}
if (!defining_alias && !ppconf.noaliases) {
/* It is an alias macro; follow the alias link */
SMacro *s;
smac->in_progress++;
s = define_smacro(tok_text(smac->expansion), casesense,
expansion, tmpl);
smac->in_progress--;
return s;
}
}
if (casesense ^ smac->casesense) {
/*
*/
nasm_warn(WARN_PP_MACRO_DEF_CASE_SINGLE, "case %ssensitive definition of macro `%s' will shadow %ssensitive macro `%s'",
casesense ? "" : "in",
mname,
smac->casesense ? "" : "in",
smac->name);
defined = false;
} else if ((!!nparam) ^ (!!smac->nparam)) {
/*
* The immediately previous versions of NASM considered
* this an error, so promote this warning is promoted to
* to error by default.
*/
nasm_warn(WARN_PP_MACRO_DEF_PARAM_SINGLE,
"macro `%s' defined both with and without parameters",
mname);
defined = false;
} else if (smac->nparam < nparam) {
nasm_warn(WARN_PP_MACRO_DEF_GREEDY_SINGLE,
"defining macro `%s' shadows previous greedy definition",
mname);
defined = false;
}
}
if (defined) {
/*
* We're redefinining, so we have to take over an
* existing SMacro structure. This means freeing
* what was already in it, but not the structure itself.
*/
clear_smacro(smac);
} else {
/* Create a new macro */
smtbl = ctx ? &ctx->localmac : &smacros;
smhead = (SMacro **) hash_findi_add(smtbl, mname);
nasm_new(smac);
smac->next = *smhead;
*smhead = smac;
}
smac->name = nasm_strdup(mname);
smac->casesense = casesense;
smac->expansion = reverse_tokens(expansion);
smac->expand = smacro_expand_default;
smac->nparam = nparam;
smac->nparam_min = nparam;
if (tmpl) {
smac->params = tmpl->params;
smac->alias = tmpl->alias;
smac->recursive = tmpl->recursive;
if (tmpl->expand) {
smac->expand = tmpl->expand;
smac->expandpvt = tmpl->expandpvt;
}
if (nparam) {
int nparam_min = nparam;
smac->varadic =
!!(tmpl->params[nparam-1].flags &
(SPARM_GREEDY|SPARM_VARADIC));
while (nparam_min > 1) {
if (!(tmpl->params[nparam_min-1].flags & SPARM_OPTIONAL))
break;
nparam_min--;
}
smac->nparam_min = nparam_min;
}
}
if (ppdbg & (PDBG_SMACROS|PDBG_LIST_SMACROS)) {
list_smacro_def((smac->alias ? PP_DEFALIAS : PP_DEFINE)
+ !casesense, ctx, smac);
}
return smac;
fail:
delete_tlist(expansion);
if (tmpl)
free_smacro_members(tmpl);
return NULL;
}
/*
* Undefine an smacro
*/
static void undef_smacro(const char *mname, bool undefalias)
{
SMacro **smhead, *s, **sp;
struct hash_table *smtbl;
Context *ctx;
ctx = get_ctx(mname, &mname);
smtbl = ctx ? &ctx->localmac : &smacros;
smhead = (SMacro **)hash_findi(smtbl, mname, NULL);
if (smhead) {
/*
* We now have a macro name... go hunt for it.
*/
sp = smhead;
while ((s = *sp) != NULL) {
if (!mstrcmp(s->name, mname, s->casesense)) {
if (s->alias && !undefalias) {
if (!ppconf.noaliases) {
if (s->in_progress) {
nasm_nonfatal("macro alias loop");
} else {
s->in_progress = true;
undef_smacro(tok_text(s->expansion), false);
s->in_progress = false;
}
}
} else {
if (list_option('d'))
list_smacro_def(s->alias ? PP_UNDEFALIAS : PP_UNDEF,
ctx, s);
*sp = s->next;
free_smacro(s);
continue;
}
}
sp = &s->next;
}
}
}
/*
* Parse a mmacro specification.
*/
static bool parse_mmacro_spec(Token *tline, MMacro *def, const char *directive)
{
tline = tline->next;
tline = skip_white(tline);
tline = expand_id(tline);
if (!tok_is(tline, TOKEN_ID)) {
nasm_nonfatal("`%s' expects a macro name", directive);
return false;
}
#if 0
def->prev = NULL;
#endif
def->name = dup_text(tline);
def->plus = false;
def->nolist = 0;
def->nparam_min = 0;
def->nparam_max = 0;
tline = expand_smacro(tline->next);
tline = skip_white(tline);
if (!tok_is(tline, TOKEN_NUM))
nasm_nonfatal("`%s' expects a parameter count", directive);
else
def->nparam_min = def->nparam_max = read_param_count(tok_text(tline));
if (tline && tok_is(tline->next, '-')) {
tline = tline->next->next;
if (tok_is(tline, '*')) {
def->nparam_max = INT_MAX;
} else if (!tok_is(tline, TOKEN_NUM)) {
nasm_nonfatal("`%s' expects a parameter count after `-'", directive);
} else {
def->nparam_max = read_param_count(tok_text(tline));
if (def->nparam_min > def->nparam_max) {
nasm_nonfatal("minimum parameter count exceeds maximum");
def->nparam_max = def->nparam_min;
}
}
}
if (tline && tok_is(tline->next, '+')) {
tline = tline->next;
def->plus = true;
}
if (tline && tok_is(tline->next, TOKEN_ID) &&
tline->next->len == 7 &&
!nasm_stricmp(tline->next->text.a, ".nolist")) {
tline = tline->next;
if (!list_option('f'))
def->nolist |= NL_LIST|NL_LINE;
}
/*
* Handle default parameters.
*/
def->ndefs = 0;
if (tline && tline->next) {
Token **comma;
def->dlist = tline->next;
tline->next = NULL;
comma = count_mmac_params(def->dlist, &def->ndefs, &def->defaults);
if (!ppconf.sane_empty_expansion && comma) {
*comma = NULL;
def->ndefs--;
nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY,
"dropping trailing empty default parameter in definition of multi-line macro `%s'",
def->name);
}
} else {
def->dlist = NULL;
def->defaults = NULL;
}
def->expansion = NULL;
if (def->defaults && def->ndefs > def->nparam_max - def->nparam_min &&
!def->plus) {
nasm_warn(WARN_PP_MACRO_DEFAULTS,
"too many default macro parameters in macro `%s'", def->name);
}
return true;
}
/*
* Decode a size directive
*/
static int parse_size(const char *str) {
struct tokenval tv;
if (nasm_token_hash(str, &tv) != TOKEN_SIZE)
return 0;
return tv.t_inttwo;
}
/*
* Process a preprocessor %pragma directive. Currently there are none.
* Gets passed the token list starting with the "preproc" token from
* "%pragma preproc".
*/
static void do_pragma_preproc(Token *tline)
{
const char *txt;
/* Skip to the real stuff */
tline = tline->next;
tline = skip_white(tline);
if (!tok_is(tline, TOKEN_ID))
return;
txt = tok_text(tline);
if (!nasm_stricmp(txt, "sane_empty_expansion")) {
tline = skip_white(tline->next);
ppconf.sane_empty_expansion =
pp_get_boolean_option(tline, ppconf.sane_empty_expansion);
} else {
/* Unknown pragma, ignore for now */
}
}
static const char *get_id_noskip(Token **tp, const char *dname);
static const char *get_id(Token **tp, const char *dname)
{
*tp = (*tp)->next; /* Skip directive */
return get_id_noskip(tp, dname);
}
static const char *get_id_noskip(Token **tp, const char *dname)
{
const char *id;
Token *t = *tp;
t = skip_white(t);
t = expand_id(t);
if (!tok_macro_id(t)) {
nasm_nonfatal("`%s' expects a macro identifier", dname);
return NULL;
}
id = tok_text(t);
nasm_assert(!tok_white(t)); /* Had skip_white() here?? */
*tp = t;
return id;
}
/* Parse a %use package name and find the package. Set *err on syntax error. */
static const struct use_package *
get_use_pkg(Token *t, const char *dname, const char **name)
{
const char *id;
t = skip_white(t);
t = expand_smacro(t);
*name = NULL;
if (!t) {
nasm_nonfatal("`%s' expects a package name, got end of line", dname);
return NULL;
} else if (t->type != TOKEN_ID && t->type != TOKEN_STR) {
nasm_nonfatal("`%s' expects a package name, got `%s'",
dname, tok_text(t));
return NULL;
}
*name = id = unquote_token(t);
t = t->next;
t = skip_white(t);
if (t) {
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after `%s' ignored", dname);
}
return nasm_find_use_package(id);
}
/*
* Mark parameter tokens in an smacro definition. If the type argument
* is 0, create smac param tokens, otherwise use the type specified;
* normally this is used for TOKEN_XDEF_PARAM, which is used to protect
* parameter tokens during expansion during %xdefine.
*
* tmpl may not be NULL here.
*/
static void mark_smac_params(Token *tline, const SMacro *tmpl,
enum token_type type)
{
const struct smac_param *params = tmpl->params;
int nparam = tmpl->nparam;
Token *t;
int i;
list_for_each(t, tline) {
if (t->type != TOKEN_ID && t->type != TOKEN_XDEF_PARAM)
continue;
for (i = 0; i < nparam; i++) {
if (tok_text_match(t, &params[i].name))
t->type = type ? type : tok_smac_param(i);
}
}
}
/**
* %clear selected macro sets either globally or in contexts
*/
static void do_clear(enum clear_what what, bool context)
{
if (context) {
if (what & CLEAR_ALLDEFINE) {
Context *ctx;
list_for_each(ctx, cstk)
clear_smacro_table(&ctx->localmac, what);
}
/* Nothing else can be context-local */
} else {
if (what & CLEAR_ALLDEFINE)
clear_smacro_table(&smacros, what);
if (what & CLEAR_MMACRO)
free_mmacro_table(&mmacros);
}
}
/*
* Process a %line directive, including the gcc/cpp compatibility
* form with a # at the front.
*/
static int line_directive(Token *origline, Token *tline)
{
int k, m;
bool err;
const char *dname;
/*
* Valid syntaxes:
* %line nnn[+mmm] [filename]
* %line nnn[+mmm] "filename" flags...
*
* "flags" are for gcc compatibility and are currently ignored.
*
* "#" at the beginning of the line is also treated as a %line
* directive, again for compatibility with gcc.
*/
if ((ppopt & PP_NOLINE) || istk->mstk.mstk)
goto done;
dname = tok_text(tline);
tline = tline->next;
tline = skip_white(tline);
if (!tok_is(tline, TOKEN_NUM)) {
nasm_nonfatal("`%s' expects a line number", dname);
goto done;
}
k = readnum(tok_text(tline), &err);
m = 1;
tline = tline->next;
if (tok_is(tline, '+') || tok_is(tline, '-')) {
bool minus = tok_is(tline, '-');
tline = tline->next;
if (!tok_is(tline, TOKEN_NUM)) {
nasm_nonfatal("`%s' expects a line increment", dname);
goto done;
}
m = readnum(tok_text(tline), &err);
if (minus)
m = -m;
tline = tline->next;
}
tline = skip_white(tline);
if (tline) {
if (tline->type == TOKEN_STR) {
const char *fname;
/*
* If this is a quoted string, ignore anything after
* it; this allows for compatibility with gcc's
* additional flags options.
*/
fname = unquote_token_anystr(tline, BADCTL,
dname[0] == '#' ? STR_C : STR_NASM);
src_set_fname(fname);
} else {
char *fname;
fname = detoken(tline, false);
src_set_fname(fname);
nasm_free(fname);
}
}
src_set_linnum(k);
istk->where = src_where();
istk->lineinc = m;
goto done;
done:
delete_tlist(origline);
return DIRECTIVE_FOUND;
}
/*
* Used for the %arg and %local directives
*/
static void define_stack_smacro(const char *name, int offset)
{
Token *tt;
tt = make_tok_char(NULL, ')');
tt = make_tok_num(tt, offset);
if (!tok_is(tt, '-'))
tt = make_tok_char(tt, '+');
tt = new_Token(tt, TOKEN_ID, StackPointer, 0);
tt = make_tok_char(tt, '(');
define_smacro(name, true, tt, NULL);
}
/*
* This implements the %assign directive: expand an smacro expression,
* then evaluate it, and assign the corresponding number to an smacro.
*/
static void assign_smacro(const char *mname, bool casesense,
Token *tline, const char *dname)
{
struct ppscan pps;
expr *evalresult;
struct tokenval tokval;
tline = expand_smacro(tline);
pps.tptr = tline;
pps.ntokens = -1;
tokval.t_type = TOKEN_INVALID;
evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
delete_tlist(tline);
if (!evalresult)
return;
if (tokval.t_type) {
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after expression ignored");
}
if (!is_simple(evalresult)) {
nasm_nonfatal("non-constant value given to `%s'", dname);
} else {
tline = make_tok_num(NULL, reloc_value(evalresult));
/*
* 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.
*/
define_smacro(mname, casesense, tline, NULL);
}
}
/*
* Implement string concatenation as used by the %strcat directive
* and function.
*/
static Token *pp_strcat(Token *tline, const char *dname)
{
size_t len;
Token *t;
Token *res = NULL;
char *q, *qbuf;
len = 0;
list_for_each(t, tline) {
switch (t->type) {
case TOKEN_WHITESPACE:
case TOKEN_COMMA:
break;
case TOKEN_STR:
unquote_token(t);
/* fall through */
case TOKEN_INTERNAL_STR:
len += t->len;
break;
default:
nasm_nonfatal("non-string passed to `%s': %s", dname,
tok_text(t));
goto err;
}
}
q = qbuf = nasm_malloc(len+1);
list_for_each(t, tline) {
if (t->type == TOKEN_INTERNAL_STR)
q = mempcpy(q, tok_text(t), t->len);
}
*q = '\0';
res = make_tok_qstr_len(NULL, qbuf, len);
nasm_free(qbuf);
err:
delete_tlist(tline);
return res;
}
/*
* Implement substring extraction as used by the %substr directive
* and function.
*/
static Token *pp_substr_common(Token *t, int64_t start, int64_t count);
static const char *pp_get_substr(Token *t, int64_t start, int64_t *countp);
static Token *pp_substr(Token *tline, const char *dname)
{
int64_t start, count;
struct ppscan pps;
Token *t;
Token *res = NULL;
expr *evalresult;
struct tokenval tokval;
t = skip_white(tline);
if (!tok_is(t, TOKEN_STR)) {
nasm_nonfatal("`%s' requires a string as parameter", dname);
goto err;
}
pps.tptr = skip_white(t->next);
if (tok_is(pps.tptr, TOKEN_COMMA))
pps.tptr = skip_white(pps.tptr->next);
if (!pps.tptr) {
nasm_nonfatal("`%s' requires a starting index", dname);
goto err;
}
pps.ntokens = -1;
tokval.t_type = TOKEN_INVALID;
evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
if (!evalresult) {
goto err;
} else if (!is_simple(evalresult)) {
nasm_nonfatal("non-constant value given to `%s'", dname);
goto err;
}
start = evalresult->value;
pps.tptr = skip_white(pps.tptr);
if (!pps.tptr) {
count = 1; /* Backwards compatibility: one character */
} else {
tokval.t_type = TOKEN_INVALID;
evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
if (!evalresult) {
goto err;
} else if (!is_simple(evalresult)) {
nasm_nonfatal("non-constant value given to `%s'", dname);
goto err;
}
count = evalresult->value;
}
res = pp_substr_common(t, start, count);
err:
delete_tlist(tline);
return res;
}
static const char *pp_get_substr(Token *t, int64_t start, int64_t *countp)
{
size_t len;
int64_t count = *countp;
unquote_token(t);
len = t->len;
/* make start and count being in range */
start -= 1; /* First character is 1 */
if (start < 0)
start = 0;
if (count < 0)
count = len + count + 1 - start;
if (start + count > (int64_t)len)
count = len - start;
if (!len || count < 0 || start >= (int64_t)len)
start = -1; /* empty string */
if (start < 0) {
*countp = 0;
return "";
} else {
*countp = count;
return tok_text(t) + start;
}
}
static Token *pp_substr_common(Token *t, int64_t start, int64_t count)
{
const char *txt = pp_get_substr(t, start, &count);
return make_tok_qstr_len(NULL, txt, count);
}
/*
* %exitmacro (named = true) or %exitrep (named = false);
* returns the MMacro structure being exited.
*/
static MMacro *do_exit_macro(const char *dname, bool named)
{
Line *l;
/*
* We must search along istk->expansion until we hit a
* macro-end marker for a macro with a name. Then we
* suppress all lines between exitmacro and endmacro.
*/
list_for_each(l, istk->expansion) {
if (l->finishes && (!!l->finishes->name == named))
break;
}
if (l) {
Line *ll;
for (ll = istk->expansion; ll != l; ll = ll->next)
ll->suppressed = true;
return l->finishes;
} else {
nasm_nonfatal("`%s' not within `%%%s' block", dname, dname+5);
return NULL;
}
}
/*
* Issue a user-originated error message
*/
static void user_error(enum preproc_token op, Token **tlinep)
{
Token *tline, *t;
char *p;
const char *q;
errflags severity;
switch (op) {
case PP_NOTE:
severity = ERR_NOTE;
break;
case PP_WARNING:
severity = ERR_WARNING|WARN_USER|ERR_PASS2;
break;
case PP_ERROR:
/* Only error out if this is the final pass */
severity = ERR_NONFATAL|ERR_PASS2;
break;
case PP_FATAL:
severity = ERR_FATAL;
break;
default:
panic();
}
*tlinep = tline = expand_smacro(skip_white(*tlinep));
t = skip_tok_white(tline);
if (tok_is(tline, TOKEN_STR) && !t) {
/* The line contains only a quoted string */
p = NULL; /* Don't try to free */
q = unquote_token(tline); /* Ignore NUL character truncation */
} else {
/* Not a quoted string, or more than one quoted string */
q = p = detoken(tline, false);
}
q = nasm_skip_spaces(q);
if (!*q)
q = pp_directives[op]; /* Less confusing than an empty message */
nasm_error(severity, "%s", q);
nasm_free(p); /* p == NULL if nothing to free */
}
/**
* find and process preprocessor directive in passed line
* Find out if a line contains a preprocessor directive, and deal
* with it if so.
*
* If a directive _is_ found, it is the responsibility of this routine
* (and not the caller) to delete_tlist() the line.
*
* @param tline a pointer to the current tokeninzed line linked list
* @param output if this directive generated output
* @param suppressed if this input line was suppressed (look for condition end)
* @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
*
*/
static int do_directive(Token *tline, Token **output, bool suppressed)
{
enum preproc_token op;
int j;
enum nolist_flags nolist;
bool casesense;
int offset;
const char *p;
char *q;
const char *mname;
struct ppscan pps;
Include *inc;
Context *ctx;
Cond *cond;
MMacro *mmac, **mmhead;
Token *t = NULL, *tt, *macro_start, *origline;
struct tokenval tokval;
expr *evalresult;
int64_t count;
const char *dname; /* Name of directive, for messages */
*output = NULL; /* No output generated */
origline = tline;
/* cpp-like line directive, must not be preceded by whitespace */
if (tok_is(tline, '#'))
return line_directive(origline, tline);
tline = skip_white(tline);
if (!tline)
return NO_DIRECTIVE_FOUND;
dname = tok_text(tline);
switch (tline->type) {
case TOKEN_PREPROC_ID:
op = pp_get_nasm_directive(dname);
if (op == PP_invalid) {
/* Look to see if it is a misspelled or future conditional */
if (!nasm_strnicmp(dname, "%if", 3))
op = PP_IF_BOGUS;
else if (!nasm_strnicmp(dname, "%elif", 5))
op = PP_ELIF_BOGUS;
}
break;
case TOKEN_ID:
op = pp_get_tasm_directive(tok_text(tline));
break;
default:
op = PP_invalid;
break;
}
switch (op) {
case PP_invalid:
return NO_DIRECTIVE_FOUND;
case PP_LINE:
/*
* %line directives are always processed immediately and
* unconditionally, as they are intended to reflect position
* in externally preprocessed sources.
*/
return line_directive(origline, tline);
default:
break;
}
if (op == PP_invalid)
return NO_DIRECTIVE_FOUND;
if (unlikely(ppopt & PP_TRIVIAL))
goto done;
casesense = true;
if (PP_HAS_CASE(op) & PP_INSENSITIVE(op)) {
casesense = false;
op--;
}
/*
* 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 (suppressed && !is_condition(op)) {
return NO_DIRECTIVE_FOUND;
}
/*
* If we're defining a macro or reading a %rep block, we should
* ignore all directives except for %macro/%imacro (which nest),
* %endm/%endmacro, %line and (only if we're in a %rep block) %endrep.
* If we're in a %rep block, another %rep nests, so should be let through.
*/
if (defining && op != PP_MACRO && op != PP_RMACRO &&
op != PP_ENDMACRO && op != PP_ENDM &&
(defining->name || (op != PP_ENDREP && op != PP_REP))) {
return NO_DIRECTIVE_FOUND;
}
if (defining) {
if (op == PP_MACRO || op == PP_RMACRO) {
nested_mac_count++;
return NO_DIRECTIVE_FOUND;
} else if (nested_mac_count > 0) {
if (op == PP_ENDMACRO) {
nested_mac_count--;
return NO_DIRECTIVE_FOUND;
}
}
if (!defining->name) {
if (op == PP_REP) {
nested_rep_count++;
return NO_DIRECTIVE_FOUND;
} else if (nested_rep_count > 0) {
if (op == PP_ENDREP) {
nested_rep_count--;
return NO_DIRECTIVE_FOUND;
}
}
}
}
if (pp_op_may_be_function[op]) {
if (tok_is(skip_white(tline->next), '('))
return NO_DIRECTIVE_FOUND; /* Expand as a preprocessor function */
}
switch (op) {
default:
nasm_nonfatal("unknown preprocessor directive `%s'", dname);
return NO_DIRECTIVE_FOUND; /* didn't get it */
case PP_PRAGMA:
/*
* %pragma namespace options...
*
* The namespace "preproc" is reserved for the preprocessor;
* all other namespaces generate a [pragma] assembly directive.
*
* Invalid %pragmas are ignored and may have different
* meaning in future versions of NASM.
*/
t = tline;
tline = tline->next;
t->next = NULL;
tline = zap_white(expand_smacro(tline));
if (tok_is(tline, TOKEN_ID)) {
if (!nasm_stricmp(tok_text(tline), "preproc")) {
/* Preprocessor pragma */
do_pragma_preproc(tline);
delete_tlist(tline);
} else {
/* Build the assembler directive */
/* Append bracket to the end of the output */
for (t = tline; t->next; t = t->next)
;
t->next = make_tok_char(NULL, ']');
/* Prepend "[pragma " */
t = new_White(tline);
t = new_Token(t, TOKEN_ID, "pragma", 6);
t = make_tok_char(t, '[');
tline = t;
*output = tline;
}
}
break;
case PP_STACKSIZE:
{
const char *arg;
/* Directive to tell NASM what the default stack size is. The
* default is for a 16-bit stack, and this can be overridden with
* %stacksize large.
*/
tline = skip_white(tline->next);
if (!tline || tline->type != TOKEN_ID) {
nasm_nonfatal("`%s' missing size parameter", dname);
break;
}
arg = tok_text(tline);
if (nasm_stricmp(arg, "flat") == 0) {
/* All subsequent ARG directives are for a 32-bit stack */
StackSize = 4;
StackPointer = "ebp";
ArgOffset = 8;
LocalOffset = 0;
} else if (nasm_stricmp(arg, "flat64") == 0) {
/* All subsequent ARG directives are for a 64-bit stack */
StackSize = 8;
StackPointer = "rbp";
ArgOffset = 16;
LocalOffset = 0;
} else if (nasm_stricmp(arg, "large") == 0) {
/* All subsequent ARG directives are for a 16-bit stack,
* far function call.
*/
StackSize = 2;
StackPointer = "bp";
ArgOffset = 4;
LocalOffset = 0;
} else if (nasm_stricmp(arg, "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 = 0;
} else {
nasm_nonfatal("`%s' invalid size type", dname);
}
break;
}
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 {
const char *arg;
int size = StackSize;
/* Find the argument name */
tline = skip_white(tline->next);
if (!tline || tline->type != TOKEN_ID) {
nasm_nonfatal("`%s' missing argument parameter", dname);
goto done;
}
arg = tok_text(tline);
/* Find the argument size type */
tline = tline->next;
if (!tok_is(tline, ':')) {
nasm_nonfatal("syntax error processing `%s' directive", dname);
goto done;
}
tline = tline->next;
if (!tok_is(tline, TOKEN_ID)) {
nasm_nonfatal("`%s' missing size type parameter", dname);
goto done;
}
/* Allow macro expansion of type parameter */
tt = tokenize(tok_text(tline));
tt = expand_smacro(tt);
size = parse_size(tok_text(tt));
delete_tlist(tt);
if (!size) {
nasm_nonfatal("invalid size type for `%s' missing directive", dname);
goto done;
}
/* Round up to even stack slots */
size = ALIGN(size, StackSize);
/* Now define the macro for the argument */
define_stack_smacro(arg, offset);
offset += size;
/* Move to the next argument in the list */
tline = skip_white(tline->next);
} while (tok_is(tline, ','));
ArgOffset = offset;
break;
case PP_LOCAL:
{
int total_size = 0;
/* 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 {
const char *local;
int size = StackSize;
/* Find the argument name */
tline = skip_white(tline->next);
if (!tline || tline->type != TOKEN_ID) {
nasm_nonfatal("`%s' missing argument parameter", dname);
goto done;
}
local = tok_text(tline);
/* Find the argument size type */
tline = tline->next;
if (!tok_is(tline, ':')) {
nasm_nonfatal("syntax error processing `%s' directive", dname);
goto done;
}
tline = tline->next;
if (!tok_is(tline, TOKEN_ID)) {
nasm_nonfatal("`%s' missing size type parameter", dname);
goto done;
}
/* Allow macro expansion of type parameter */
tt = tokenize(tok_text(tline));
tt = expand_smacro(tt);
size = parse_size(tok_text(tt));
delete_tlist(tt);
if (!size) {
nasm_nonfatal("invalid size type for `%s' missing directive", dname);
goto done;
}
/* Round up to even stack slots */
size = ALIGN(size, StackSize);
offset += size; /* Negative offset, increment before */
/* Now define the macro for the argument */
define_stack_smacro(local, -offset);
/* How is this different from offset? */
total_size += size;
/* Move to the next argument in the list */
tline = skip_white(tline->next);
} while (tok_is(tline, ','));
/* Now define the assign to setup the enter_c macro correctly */
tt = make_tok_num(NULL, total_size);
tt = make_tok_char(tt, '+');
tt = new_Token(tt, TOKEN_LOCAL_MACRO, "%$localsize", 11);
assign_smacro("%$localsize", true, tt, dname);
LocalOffset = offset;
break;
}
case PP_CLEAR:
{
bool context = false;
t = tline->next = expand_smacro(tline->next);
t = skip_white(t);
if (!t) {
/* Emulate legacy behavior */
do_clear(CLEAR_DEFINE|CLEAR_MMACRO, false);
} else {
while ((t = skip_white(t)) && t->type == TOKEN_ID) {
const char *txt = tok_text(t);
if (!nasm_stricmp(txt, "all")) {
do_clear(CLEAR_ALL, context);
} else if (!nasm_stricmp(txt, "define") ||
!nasm_stricmp(txt, "def") ||
!nasm_stricmp(txt, "smacro")) {
do_clear(CLEAR_DEFINE, context);
} else if (!nasm_stricmp(txt, "defalias") ||
!nasm_stricmp(txt, "alias") ||
!nasm_stricmp(txt, "salias")) {
do_clear(CLEAR_DEFALIAS, context);
} else if (!nasm_stricmp(txt, "alldef") ||
!nasm_stricmp(txt, "alldefine")) {
do_clear(CLEAR_ALLDEFINE, context);
} else if (!nasm_stricmp(txt, "macro") ||
!nasm_stricmp(txt, "mmacro")) {
do_clear(CLEAR_MMACRO, context);
} else if (!nasm_stricmp(txt, "context") ||
!nasm_stricmp(txt, "ctx")) {
context = true;
} else if (!nasm_stricmp(txt, "global")) {
context = false;
} else if (!nasm_stricmp(txt, "nothing") ||
!nasm_stricmp(txt, "none") ||
!nasm_stricmp(txt, "ignore") ||
!nasm_stricmp(txt, "-") ||
!nasm_stricmp(txt, "--")) {
/* Do nothing */
} else {
nasm_nonfatal("invalid option to %s: %s", dname, txt);
t = NULL;
}
}
}
t = skip_white(t);
if (t) {
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after `%s' ignored", dname);
}
break;
}
case PP_DEPEND:
t = pp_do_depend(&tline->next, dname);
delete_Token(t);
goto done;
case PP_INCLUDE:
case PP_REQUIRE:
{
const struct file_hash_entry *fhe;
t = tlist_filename(&tline->next, NULL, dname);
if (!t)
goto done;
nasm_new(inc);
inc->next = istk;
p = tok_text(t);
inc->fp = inc_fopen(p, deplist, &fhe,
(pp_mode == PP_DEPS) ? INC_OPTIONAL :
(op == PP_REQUIRE) ? INC_REQUIRED :
INC_NEEDED, NF_TEXT);
if (!inc->fp) {
/* -MG given but file not found, or repeated %require */
nasm_free(inc);
} else {
inc->nolist = istk->nolist;
inc->noline = istk->noline;
inc->where = istk->where;
inc->lineinc = 0;
istk = inc;
if (!istk->noline) {
src_set(0, fhe ? fhe->path : p);
istk->where = src_where();
istk->lineinc = 1;
if (ppdbg & PDBG_INCLUDE)
dfmt->debug_include(true, istk->next->where, istk->where);
}
if (!istk->nolist)
lfmt->uplevel(LIST_INCLUDE, 0);
}
delete_Token(t);
break;
}
case PP_USE:
{
const struct use_package *pkg;
const char *name;
pkg = get_use_pkg(tline->next, dname, &name);
if (!name)
goto done;
if (!pkg) {
nasm_nonfatal("unknown `%s' package: `%s'", dname, name);
} else if (!use_loaded[pkg->index]) {
/*
* Not already included, go ahead and include it.
* Treat it as an include file for the purpose of
* producing a listing.
*/
use_loaded[pkg->index] = true;
pp_start_stdmac();
pp_add_stdmac(pkg->macros);
}
break;
}
case PP_PUSH:
case PP_REPL:
case PP_POP:
tline = tline->next;
tline = skip_white(tline);
tline = expand_id(tline);
if (tline) {
if (!tok_is(tline, TOKEN_ID)) {
nasm_nonfatal("`%s' expects a context identifier", dname);
goto done;
}
if (skip_white(tline->next)) {
nasm_warn(WARN_PP_TRAILING, "trailing garbage after `%s' ignored",
dname);
}
p = tok_text(tline);
} else {
p = NULL; /* Anonymous */
}
if (op == PP_PUSH) {
nasm_new(ctx);
ctx->depth = cstk ? cstk->depth + 1 : 1;
ctx->next = cstk;
ctx->name = p ? nasm_strdup(p) : NULL;
ctx->number = unique++;
cstk = ctx;
} else {
/* %pop or %repl */
if (!cstk) {
nasm_nonfatal("`%s': context stack is empty", dname);
} else if (op == PP_POP) {
if (p && (!cstk->name || nasm_stricmp(p, cstk->name)))
nasm_nonfatal("`%s' in wrong context: %s, "
"expected %s",
dname, cstk->name ? cstk->name : "anonymous", p);
else
ctx_pop();
} else {
/* op == PP_REPL */
nasm_free((char *)cstk->name);
cstk->name = p ? nasm_strdup(p) : NULL;
p = NULL;
}
}
break;
case PP_FATAL:
case PP_ERROR:
case PP_WARNING:
case PP_NOTE:
user_error(op, &tline->next);
break;
CASE_PP_IF:
if (suppressed || (istk->conds && !emitting(istk->conds->state))) {
/*
* Don't evaluate the actual condition inside of a dead
* expansion, because it is entirely valid for it to be
* syntactically broken at this point. There is no point,
* anyway: the output from all branches of this conditionals
* will be suppressed, and the only reason this is being
* processed at all is to look for nested conditionals.
*/
j = COND_NEVER;
} else {
j = if_condition(tline->next, op, dname);
tline->next = NULL; /* it got freed */
}
cond = nasm_malloc(sizeof(Cond));
cond->next = istk->conds;
cond->state = j;
istk->conds = cond;
if(istk->mstk.mstk)
istk->mstk.mstk->condcnt++;
break;
CASE_PP_ELIF:
if (!istk->conds) {
nasm_nonfatal("`%s': no matching `%%if'", dname);
break;
}
switch(istk->conds->state) {
case COND_IF_TRUE:
istk->conds->state = COND_DONE;
break;
case COND_DONE:
case COND_NEVER:
break;
case COND_ELSE_TRUE:
case COND_ELSE_FALSE:
nasm_warn(WARN_PP_ELSE_ELIF|ERR_PP_PRECOND,
"`%s' after `%%else', ignoring content", dname);
istk->conds->state = COND_NEVER;
break;
case COND_IF_FALSE:
/*
* 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), op, dname);
tline->next = NULL; /* it got freed */
istk->conds->state = j;
break;
}
break;
case PP_ELSE:
if (tline->next)
nasm_warn(WARN_PP_TRAILING|ERR_PP_PRECOND,
"trailing garbage after `%s' ignored", dname);
if (!istk->conds) {
nasm_nonfatal("`%s': no matching `%%if'", dname);
break;
}
switch(istk->conds->state) {
case COND_IF_TRUE:
case COND_DONE:
istk->conds->state = COND_ELSE_FALSE;
break;
case COND_NEVER:
break;
case COND_IF_FALSE:
istk->conds->state = COND_ELSE_TRUE;
break;
case COND_ELSE_TRUE:
case COND_ELSE_FALSE:
nasm_warn(WARN_PP_ELSE_ELSE|ERR_PP_PRECOND,
"`%s' after `%%else', ignoring content", dname);
istk->conds->state = COND_NEVER;
break;
}
break;
case PP_ENDIF:
if (tline->next) {
nasm_warn(WARN_PP_TRAILING|ERR_PP_PRECOND,
"trailing garbage after `%s' ignored", dname);
}
if (!istk->conds) {
nasm_nonfatal("`%s': no matching `%%if'", dname);
break;
}
cond = istk->conds;
istk->conds = cond->next;
nasm_free(cond);
if(istk->mstk.mstk)
istk->mstk.mstk->condcnt--;
break;
case PP_RMACRO:
case PP_MACRO:
{
MMacro *def;
nasm_assert(!defining);
def = new_mmacro();
def->casesense = casesense;
if (op == PP_RMACRO)
def->max_depth = nasm_limit[LIMIT_MACRO_LEVELS];
if (!parse_mmacro_spec(tline, def, dname)) {
free_mmacro(def);
goto done;
}
/*
* dstk.mstk points to the previous definition bracket,
* whereas dstk.mmac points to the topmost mmacro, which
* in this case is the one we are just starting to create.
*/
/* def->dstk.mstk = defining == NULL */
def->dstk.mmac = get_mmacro(def);
defining = get_mmacro(def);
defining->where = istk->where;
mmac = (MMacro *) hash_findix(&mmacros, 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)) {
nasm_warn(WARN_PP_MACRO_REDEF_MULTI,
"redefining multi-line macro `%s'",
defining->name);
break;
}
mmac = mmac->next;
}
break;
}
case PP_ENDM:
case PP_ENDMACRO:
if (!defining) {
nasm_nonfatal("`%s': not defining a macro", dname);
goto done;
} else if (!defining->name) {
nasm_nonfatal("expected `%%endrep' before `%s'", dname);
goto done;
}
pop_mstk(&defining->dstk, defining->dstk.mstk);
if (defining->refcnt != 1)
nasm_panic("defining->refcnt == %"PRIzu, defining->refcnt);
mmhead = (MMacro **) hash_findi_add(&mmacros, defining->name);
defining->next = *mmhead;
*mmhead = defining; /* Linked list inherits defining's refcnt */
defining = NULL;
break;
case PP_EXITMACRO:
do_exit_macro(dname, true);
break;
case PP_UNIMACRO:
casesense = false;
/* fall through */
case PP_UNMACRO:
{
MMacro **mmac_p;
MMacro spec;
nasm_zero(spec);
spec.casesense = casesense;
if (!parse_mmacro_spec(tline, &spec, dname)) {
goto done;
}
mmac_p = (MMacro **) hash_findi(&mmacros, spec.name, NULL);
if (!mmac_p) {
/* No such macro */
delete_tlist(spec.dlist);
break;
}
while (mmac_p && *mmac_p) {
mmac = *mmac_p;
if (mmac->casesense == spec.casesense &&
!mstrcmp(mmac->name, spec.name, spec.casesense) &&
mmac->nparam_min == spec.nparam_min &&
mmac->nparam_max == spec.nparam_max &&
mmac->plus == spec.plus) {
*mmac_p = mmac->next;
} else {
mmac_p = &mmac->next;
}
}
delete_tlist(spec.dlist);
break;
}
case PP_ROTATE:
while (tok_white(tline->next))
tline = tline->next;
if (!tline->next) {
delete_tlist(origline);
nasm_nonfatal("`%s' missing rotate count", dname);
return DIRECTIVE_FOUND;
}
t = expand_smacro(tline->next);
tline->next = NULL;
pps.tptr = tline = t;
pps.ntokens = -1;
tokval.t_type = TOKEN_INVALID;
evalresult =
evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
delete_tlist(tline);
if (!evalresult)
return DIRECTIVE_FOUND;
if (tokval.t_type) {
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after expression ignored");
}
if (!is_simple(evalresult)) {
nasm_nonfatal("non-constant value given to `%s'", dname);
return DIRECTIVE_FOUND;
}
mmac = istk->mstk.mmac;
if (!mmac) {
nasm_nonfatal("`%s' invoked outside a macro call", dname);
} else if (mmac->nparam == 0) {
nasm_nonfatal("`%s' invoked within macro without parameters", dname);
} else {
int rotate = mmac->rotate + reloc_value(evalresult);
rotate %= (int)mmac->nparam;
if (rotate < 0)
rotate += mmac->nparam;
mmac->rotate = rotate;
}
break;
case PP_REP:
{
MMacro *def;
nolist = 0;
tline = skip_white(tline->next);
if (tok_is(tline, TOKEN_ID) && tline->len == 7 &&
!nasm_memicmp(tline->text.a, ".nolist", 7)) {
if (!list_option('f'))
nolist |= NL_LIST; /* ... but update line numbers */
tline = skip_white(tline->next);
}
if (tline) {
pps.tptr = expand_smacro(tline);
pps.ntokens = -1;
tokval.t_type = TOKEN_INVALID;
/* XXX: really critical?! */
evalresult =
evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
if (!evalresult)
goto done;
if (tokval.t_type)
nasm_warn(WARN_PP_TRAILING, "trailing garbage after expression ignored");
if (!is_simple(evalresult)) {
nasm_nonfatal("non-constant value given to `%s'", dname);
goto done;
}
count = reloc_value(evalresult);
if (count > nasm_limit[LIMIT_REP]) {
nasm_nonfatal("`%s' count %"PRId64" exceeds limit (currently %"PRId64")",
dname, count, nasm_limit[LIMIT_REP]);
count = 0;
} else if (count < 0) {
nasm_warn(ERR_PASS2|WARN_PP_REP_NEGATIVE,
"negative `%s' count: %"PRId64, dname, count);
count = 0;
} else {
count++;
}
} else {
nasm_nonfatal("`%s' expects a repeat count", dname);
count = 0;
}
def = new_mmacro();
def->nolist = nolist;
def->in_progress = count;
def->mstk.mstk = get_mmacro(istk->mstk.mstk);
def->mstk.mmac = get_mmacro(istk->mstk.mmac);
def->dstk.mstk = defining; /* Inherits defining's refcount */
def->dstk.mmac = defining ? get_mmacro(defining->dstk.mmac) : NULL;
def->where = istk->where;
defining = get_mmacro(def);
break;
}
case PP_ENDREP:
{
Line *l;
if (!defining || defining->name) {
nasm_nonfatal("`%%endrep': no matching `%%rep'");
goto done;
}
/*
* 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.
*/
nasm_new(l);
l->next = istk->expansion;
l->finishes = get_mmacro(defining);
l->first = NULL;
l->where = src_where();
istk->expansion = l;
/* A loop does not change istk->noline */
istk->nolist += !!(defining->nolist & NL_LIST);
if (!istk->nolist)
lfmt->uplevel(LIST_MACRO, 0);
put_mmacro(&defining->dstk.mmac);
/* These inherit the respective refcounts */
pop_mmacro(&istk->mstk.mstk, defining);
defining = defining->dstk.mstk;
break;
}
case PP_EXITREP:
{
MMacro *m = do_exit_macro(dname, false);
m->in_progress = 1; /* No more repeats */
break;
}
case PP_DEFINE:
case PP_XDEFINE:
case PP_DEFALIAS:
{
SMacro tmpl;
Token **lastp;
int nparam;
if (!(mname = get_id(&tline, dname)))
goto done;
nasm_zero(tmpl);
lastp = &tline->next;
nparam = parse_smacro_template(&lastp, &tmpl);
tline = *lastp;
*lastp = NULL;
if (unlikely(op == PP_DEFALIAS)) {
macro_start = tline;
if (!tok_macro_id(macro_start)) {
nasm_nonfatal("`%s' expects a macro identifier to alias",
dname);
goto done;
}
tt = macro_start->next;
macro_start->next = NULL;
tline = tline->next;
tline = skip_white(tline);
if (tline && tline->type) {
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after aliasing identifier ignored");
}
delete_tlist(tt);
tmpl.alias = true;
} else {
if (op == PP_XDEFINE) {
/* Protect macro parameter tokens */
if (nparam)
mark_smac_params(tline, &tmpl, TOKEN_XDEF_PARAM);
tline = expand_smacro(tline);
}
macro_start = tline;
}
/*
* 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
* delete_tlist have the rest of the line (which we have
* carefully re-terminated after chopping off the expansion
* from the end).
*/
define_smacro(mname, casesense, macro_start, &tmpl);
break;
}
case PP_UNDEF:
case PP_UNDEFALIAS:
if (!(mname = get_id(&tline, dname)))
goto done;
if (tline->next)
nasm_warn(WARN_PP_TRAILING,
"trailing garbage after macro name ignored");
undef_smacro(mname, op == PP_UNDEFALIAS);
break;
case PP_DEFSTR:
if (!(mname = get_id(&tline, dname)))
goto done;
tline = expand_smacro(cut_tlist(tline));
tline = zap_white(tline);
q = detoken(tline, false);
macro_start = make_tok_qstr(NULL, q);
nasm_free(q);
/*
* We now have a macro name, an implicit parameter count of
* zero, and a string token to use as an expansion. Create
* and store an SMacro.
*/
define_smacro(mname, casesense, macro_start, NULL);
break;
case PP_DEFTOK:
if (!(mname = get_id(&tline, dname)))
goto done;
tline = expand_smacro(cut_tlist(tline));
t = skip_white(tline);
/* t should now point to the string */
if (!tok_is(t, TOKEN_STR)) {
nasm_nonfatal("`%s' requires string as second parameter", dname);
delete_tlist(tline);
goto done;
}
/*
* Convert the string to a token stream.
*/
macro_start = tokenize(unquote_token_cstr(t));
/*
* 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.
*/
define_smacro(mname, casesense, macro_start, NULL);
delete_tlist(tline);
break;
case PP_PATHSEARCH:
{
if (!(mname = get_id(&tline, dname)))
goto done;
macro_start = pp_do_pathsearch(&tline->next, dname);
/*
* We now have a macro name, an implicit parameter count of
* zero, and a string token to use as an expansion. Create
* and store an SMacro.
*/
if (macro_start)
define_smacro(mname, casesense, macro_start, NULL);
break;
}
case PP_STRLEN:
if (!(mname = get_id(&tline, dname)))
goto done;
tline = expand_smacro(cut_tlist(tline));
t = skip_white(tline);
/* t should now point to the string */
if (!tok_is(t, TOKEN_STR)) {
nasm_nonfatal("`%s' requires string as second parameter", dname);
delete_tlist(tline);
delete_tlist(origline);
return DIRECTIVE_FOUND;
}
unquote_token(t);
macro_start = make_tok_num(NULL, t->len);
/*
* 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.
*/
define_smacro(mname, casesense, macro_start, NULL);
delete_tlist(tline);
delete_tlist(origline);
return DIRECTIVE_FOUND;
case PP_STRCAT:
if (!(mname = get_id(&tline, dname)))
goto done;
tline = expand_smacro(cut_tlist(tline));
macro_start = pp_strcat(tline, dname);
/*
* We now have a macro name, an implicit parameter count of
* zero, and a string token to use as an expansion. Create
* and store an SMacro.
*/
if (macro_start)
define_smacro(mname, casesense, macro_start, NULL);
break;
case PP_SUBSTR:
if (!(mname = get_id(&tline, dname)))
goto done;
tline = expand_smacro(cut_tlist(tline));
macro_start = pp_substr(tline, dname);
/*
* We now have a macro name, an implicit parameter count of
* zero, and a string token to use as an expansion. Create
* and store an SMacro.
*/
if (macro_start)
define_smacro(mname, casesense, macro_start, NULL);
break;
case PP_ASSIGN:
if (!(mname = get_id(&tline, dname)))
goto done;
tline = cut_tlist(tline);
assign_smacro(mname, casesense, tline, dname);
goto done;
case PP_ALIASES:
tline = tline->next;
tline = expand_smacro(tline);
ppconf.noaliases = !pp_get_boolean_option(tline, !ppconf.noaliases);
break;
case PP_LINE:
nasm_panic("`%s' directive not preprocessed early", dname);
break;
case PP_NULL:
/* Goes nowhere, does nothing */
break;
}
done:
delete_tlist(origline);
return DIRECTIVE_FOUND;
}
/*
* Ensure that a macro parameter contains a condition code and
* nothing else. Return the condition code index if so, or -1
* otherwise.
*/
static int find_cc(Token * t)
{
Token *tt;
if (!t)
return -1; /* Probably a %+ without a space */
t = skip_white(t);
if (!tok_is(t, TOKEN_ID))
return -1;
tt = t->next;
tt = skip_white(tt);
if (tok_isnt(tt, ','))
return -1;
return bsii(tok_text(t), (const char **)conditions,
ARRAY_SIZE(conditions));
}
enum concat_flags {
CONCAT_ID = 0x01,
CONCAT_LOCAL_MACRO = 0x02,
CONCAT_ENVIRON = 0x04,
CONCAT_PREPROC_ID = 0x08,
CONCAT_NUM = 0x10,
CONCAT_FLOAT = 0x20,
CONCAT_OP = 0x40 /* Operators */
};
struct concat_mask {
enum concat_flags mask_head;
enum concat_flags mask_tail;
};
static inline bool pp_concat_match(const Token *t, enum concat_flags mask)
{
enum concat_flags ctype = 0;
if (!t)
return false;
switch (t->type) {
case TOKEN_ID:
case TOKEN_QMARK: /* Keyword, treated as ID for pasting */
ctype = CONCAT_ID;
break;
case TOKEN_LOCAL_MACRO:
ctype = CONCAT_LOCAL_MACRO;
break;
case TOKEN_ENVIRON:
ctype = CONCAT_ENVIRON;
break;
case TOKEN_PREPROC_ID:
ctype = CONCAT_PREPROC_ID;
break;
case TOKEN_NUM:
case TOKEN_FLOAT:
ctype = CONCAT_NUM;
break;
case TOKEN_HERE:
case TOKEN_BASE:
/* NASM 2.15 treats these as operators, but is that sane? */
ctype = CONCAT_OP;
break;
case TOKEN_OTHER:
ctype = CONCAT_OP; /* For historical reasons */
break;
default:
if (t->type > TOKEN_WHITESPACE && t->type < TOKEN_MAX_OPERATOR)
ctype = CONCAT_OP;
else
ctype = 0;
}
return !!(ctype & mask);
}
/*
* This routines walks over tokens stream and handles tokens
* pasting, if @handle_explicit passed then explicit pasting
* term is handled, otherwise -- implicit pastings only.
* The @m array can contain a series of token types which are
* executed as separate passes.
*/
static bool paste_tokens(Token **head, const struct concat_mask *m,
size_t mnum, bool handle_explicit)
{
Token *tok, *t, *next, **prev_next, **prev_nonspace, **nextp;
bool pasted = false;
char *buf, *p;
size_t len, i;
/*
* The last token before pasting. We need it
* to be able to connect new handled tokens.
* In other words if there were a tokens stream
*
* A -> B -> C -> D
*
* and we've joined tokens B and C, the resulting
* stream should be
*
* A -> BC -> D
*/
tok = *head;
prev_next = prev_nonspace = head;
if (tok_white(tok) || tok_is(tok, TOKEN_PASTE))
prev_nonspace = NULL;
while (tok && (next = tok->next)) {
bool did_paste = false;
switch (tok->type) {
case TOKEN_WHITESPACE:
/* Zap redundant whitespaces */
tok->next = next = zap_white(next);
break;
case TOKEN_PASTE:
/* Explicit pasting */
if (!handle_explicit)
break;
did_paste = true;
/* Left pasting token is start of line, just drop %+ */
if (!prev_nonspace) {
prev_next = nextp = head;
t = NULL;
} else {
prev_next = prev_nonspace;
t = *prev_next;
nextp = &t->next;
}
/*
* Delete the %+ token itself plus any whitespace.
* In a sequence of %+ ... %+ ... %+ pasting sequences where
* some expansions in the middle have ended up empty,
* we can end up having multiple %+ tokens in a row;
* just drop whem in that case.
*/
next = *nextp;
while (next) {
if (next->type == TOKEN_PASTE || next->type == TOKEN_WHITESPACE)
next = delete_Token(next);
else
break;
}
*nextp = next;
/*
* Nothing after? Just leave the existing token.
*/
if (!next)
break;
if (!t) {
/* Nothing to actually paste, just zapping the paste */
*prev_next = tok = next;
break;
}
/* An actual paste */
p = buf = nasm_malloc(t->len + next->len + 1);
p = mempcpy(p, tok_text(t), t->len);
p = mempcpy(p, tok_text(next), next->len);
*p = '\0';
delete_Token(t);
t = tokenize(buf);
nasm_free(buf);
if (unlikely(!t)) {
/*
* No output at all? Replace with a single whitespace.
* This should never happen.
*/
tok = t = new_White(NULL);
} else {
*prev_nonspace = tok = t;
}
while (t->next)
t = t->next; /* Find the last token produced */
/* Delete the second token and attach to the end of the list */
t->next = delete_Token(next);
/* We want to restart from the head of the pasted token */
*prev_next = next = tok;
break;
default:
/* implicit pasting */
for (i = 0; i < mnum; i++) {
if (pp_concat_match(tok, m[i].mask_head))
break;
}
if (i >= mnum)
break;
len = tok->len;
while (pp_concat_match(next, m[i].mask_tail)) {
len += next->len;
next = next->next;
}
/* No match or no text to process */
if (len == tok->len)
break;
p = buf = nasm_malloc(len + 1);
while (tok != next) {
p = mempcpy(p, tok_text(tok), tok->len);
tok = delete_Token(tok);
}
*p = '\0';
*prev_next = tok = t = tokenize(buf);
nasm_free(buf);
/*
* Connect pasted into original stream,
* ie A -> new-tokens -> B
*/
while ((tok = t->next)) {
if (tok->type != TOKEN_WHITESPACE && tok->type != TOKEN_PASTE)
prev_nonspace = &t->next;
t = tok;
}
t->next = next;
prev_next = &t->next;
did_paste = true;
break;
}
if (did_paste) {
pasted = true;
} else {
prev_next = &tok->next;
if (next && next->type != TOKEN_WHITESPACE &&
next->type != TOKEN_PASTE)
prev_nonspace = prev_next;
}
tok = next;
}
return pasted;
}
/*
* Computes the proper rotation of mmacro parameters
*/
static int mmac_rotate(const MMacro *mac, unsigned int n)
{
if (--n < mac->nparam)
n = (n + mac->rotate) % mac->nparam;
return n+1;
}
/*
* expands to a list of tokens from %{x:y}
*/
static void expand_mmac_params_range(MMacro *mac, Token *tline, Token ***tail)
{
Token *t;
const char *arg = tok_text(tline) + 1;
int fst, lst, incr, n;
int parsed;
parsed = sscanf(arg, "%d:%d", &fst, &lst);
nasm_assert(parsed == 2);
/*
* only macros params are accounted so
* if someone passes %0 -- we reject such
* value(s)
*/
if (lst == 0 || fst == 0)
goto err;
/* the values should be sane */
if ((fst > (int)mac->nparam || fst < (-(int)mac->nparam)) ||
(lst > (int)mac->nparam || lst < (-(int)mac->nparam)))
goto err;
fst = fst < 0 ? fst + (int)mac->nparam + 1: fst;
lst = lst < 0 ? lst + (int)mac->nparam + 1: lst;
/*
* It will be at least one parameter, as we can loop
* in either direction.
*/
incr = (fst < lst) ? 1 : -1;
while (true) {
n = mmac_rotate(mac, fst);
dup_tlistn(mac->params[n], mac->paramlen[n], tail);
if (fst == lst)
break;
t = make_tok_char(NULL, ',');
**tail = t;
*tail = &t->next;
fst += incr;
}
return;
err:
nasm_nonfatal("`%%{%s}': macro parameters out of range", arg);
return;
}
/*
* Expand MMacro-local things: parameter references (%0, %n, %+n,
* %-n) and MMacro-local identifiers (%%foo) as well as
* macro indirection (%[...]) and range (%{..:..}).
*/
static Token *expand_mmac_params(Token * tline)
{
Token **tail, *thead;
bool changed = false;
MMacro * const mac = istk->mstk.mmac;
tail = &thead;
thead = NULL;
while (tline) {
bool change;
bool err_not_mac = false;
Token *t = tline;
const char *text = tok_text(t);
char *newtext = NULL;
int type = t->type;
tline = tline->next;
t->next = NULL;
switch (type) {
case TOKEN_LOCAL_SYMBOL:
change = true;
if (!mac) {
err_not_mac = true;
break;
}
type = TOKEN_ID;
text = newtext =
nasm_asprintf("..@%"PRIu64".%s", mac->unique, text+2);
break;
case TOKEN_MMACRO_PARAM:
{
Token *tt = NULL;
change = true;
if (!mac) {
err_not_mac = true;
break;
}
if (strchr(text, ':')) {
/* It is a range */
expand_mmac_params_range(mac, t, &tail);
text = NULL;
break;
}
switch (text[1]) {
/*
* We have to make a substitution of one of the
* forms %1, %-1, %+1, %%foo, %0, %00.
*/
case '0':
if (!text[2]) {
type = TOKEN_NUM;
text = newtext = nasm_asprintf("%d", mac->nparam);
break;
}
if (text[2] != '0' || text[3])
goto invalid;
/* a possible captured label == mac->params[0] */
/* fall through */
default:
{
unsigned long n;
char *ep;
n = strtoul(text + 1, &ep, 10);
if (unlikely(*ep))
goto invalid;
if (n <= mac->nparam) {
n = mmac_rotate(mac, n);
dup_tlistn(mac->params[n], mac->paramlen[n], &tail);
}
text = NULL;
break;
}
case '-':
case '+':
{
int cc;
unsigned long n;
char *ep;
n = strtoul(tok_text(t) + 2, &ep, 10);
if (unlikely(*ep))
goto invalid;
if (n && n <= mac->nparam) {
n = mmac_rotate(mac, n);
tt = mac->params[n];
}
cc = find_cc(tt);
if (cc == -1) {
nasm_nonfatal("macro parameter `%s' is not a condition code",
tok_text(t));
text = NULL;
break;
}
type = TOKEN_ID;
if (text[1] == '-') {
int ncc = inverse_ccs[cc];
if (unlikely(ncc == -1)) {
nasm_nonfatal("condition code `%s' is not invertible",
conditions[cc]);
break;
}
cc = ncc;
}
text = conditions[cc];
break;
}
invalid:
nasm_nonfatal("invalid macro parameter: `%s'", text);
text = NULL;
break;
}
break;
}
case TOKEN_PREPROC_Q:
if (mac) {
type = TOKEN_ID;
text = mac->iname;
change = true;
} else {
change = false;
}
break;
case TOKEN_PREPROC_QQ:
if (mac) {
type = TOKEN_ID;
text = mac->name;
change = true;
} else {
change = false;
}
break;
case TOKEN_INDIRECT:
{
Token *tt;
tt = tokenize(tok_text(t));
tt = expand_mmac_params(tt);
tt = expand_smacro(tt);
tail = steal_tlist(tt, tail);
text = NULL;
change = true;
break;
}
default:
change = false;
break;
}
if (err_not_mac) {
nasm_nonfatal("`%s': not in a macro call", text);
text = NULL;
change = true;
}
if (change) {
if (!text) {
delete_Token(t);
nasm_free(newtext);
} else {
size_t len = tok_strlen(text);
*tail = t;
tail = &t->next;
t->type = type;
if (!newtext)
set_text(t, text, len);
else
set_text_free(t, newtext, len);
}
changed = true;
} else {
*tail = t;
tail = &t->next;
}
}
*tail = NULL;
if (changed) {
const struct concat_mask t[] = {
{
CONCAT_ID | CONCAT_FLOAT, /* head */
CONCAT_ID | CONCAT_NUM | CONCAT_FLOAT | CONCAT_OP /* tail */
},
{
CONCAT_NUM, /* head */
CONCAT_NUM /* tail */
}
};
paste_tokens(&thead, t, ARRAY_SIZE(t), false);
}
return thead;
}
static SMacro *expand_one_smacro(Token ***tpp);
/*
* Process an smacro argument with SPARM_STR.
* This is factored out so that it is usable by preprocessor functions.
*/
static Token *
expand_sparm_str(Token *param, enum sparmflags flags)
{
Token *qs;
qs = expand_smacro_noreset(param);
if ((flags & SPARM_CONDQUOTE) && tok_is(qs, TOKEN_STR) && !qs->next) {
/* A single quoted string token - already good */
} else {
char *arg = detoken(qs, false);
delete_tlist(qs);
qs = make_tok_qstr(NULL, arg);
nasm_free(arg);
}
return qs;
}
/*
* Expand one single-line macro instance given a specific macro and a
* specific set of parameters. Returns a pointer to the expansion, and
* the pointer *epp pointing to the next pointer of the last token of
* the expansion; if the expansion is empty return NULL and *epp is
* unchanged.
*
* mstart is the token containing the token name *as invoked*.
*/
static Token *
expand_smacro_with_params(SMacro *m, Token *mstart, Token **params,
int nparam, Token ***epp)
{
/* Is it a macro or a preprocessor function? Used for diagnostics. */
const char * const mtype = m->name[0] == '%' ? "function" : "macro";
Token *t, *tline, *tup;
bool cond_comma;
const struct smac_param *mparm;
int i;
/* Expand the macro */
m->in_progress++;
/*
* Postprocessing of of parameters. Note that the ordering matters
* here.
*
* mparm points to the current parameter specification
* structure (struct smac_param); this may not match the index
* i in the case of varadic parameters.
*/
if (nparam) {
for (i = 0, mparm = m->params; i < nparam;
i++, mparm += !(mparm->flags & SPARM_VARADIC)) {
const enum sparmflags flags = mparm->flags;
if (flags & SPARM_EVAL) {
/* Evaluate this parameter as a number */
struct ppscan pps;
struct tokenval tokval;
expr *evalresult;
Token *eval_param;
eval_param = zap_white(expand_smacro_noreset(params[i]));
params[i] = NULL;
if (!eval_param) {
/* empty argument */
if (mparm->def) {
params[i] = dup_tlist(mparm->def, NULL);
continue;
} else if (flags & SPARM_OPTIONAL) {
continue;
}
/* otherwise, allow evaluate() to generate an error */
}
pps.tptr = eval_param;
pps.ntokens = -1;
tokval.t_type = TOKEN_INVALID;
evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
delete_tlist(eval_param);
if (!evalresult) {
/* Nothing meaningful to do */
} else if (tokval.t_type) {
nasm_nonfatal("invalid expression in parameter %d of %s `%s'",
i+1, mtype, m->name);
} else if (!is_simple(evalresult)) {
nasm_nonfatal("non-constant expression in parameter %d of %s `%s'",
i+1, mtype, m->name);
} else {
int64_t v = reloc_value(evalresult);
params[i] = make_tok_num_radix(NULL, v, mparm->radix,
!!(flags & SPARM_UNSIGNED));
}
}
if (flags & SPARM_STR) {
/* Convert expansion to a quoted string */
params[i] = expand_sparm_str(params[i], flags);
}
}
}
/* Note: we own the expansion this returns. */
t = m->expand(m, params, nparam);
tup = tline = NULL;
cond_comma = false;
while (t) {
enum token_type type = t->type;
Token *tnext = t->next;
switch (type) {
case TOKEN_PREPROC_Q:
case TOKEN_PREPROC_SQ:
nasm_assert(t != mstart);
delete_Token(t);
t = dup_Token(tline, mstart);
break;
case TOKEN_PREPROC_QQ:
case TOKEN_PREPROC_SQQ:
{
size_t mlen = strlen(m->name);
size_t len;
char *p, *from;
t->type = mstart->type;
if (t->type == TOKEN_LOCAL_MACRO) {
const char *psp; /* prefix start pointer */
const char *pep; /* prefix end pointer */
size_t plen;
psp = tok_text(mstart);
get_ctx(psp, &pep);
plen = pep - psp;
len = mlen + plen;
from = p = nasm_malloc(len + 1);
p = mempcpy(p, psp, plen);
} else {
len = mlen;
from = p = nasm_malloc(len + 1);
}
p = mempcpy(p, m->name, mlen+1);
set_text_free(t, from, len);
t->next = tline;
break;
}
case TOKEN_COND_COMMA:
delete_Token(t);
t = cond_comma ? make_tok_char(tline, ',') : NULL;
break;
case TOKEN_ID:
case TOKEN_PREPROC_ID:
case TOKEN_LOCAL_MACRO:
{
/*
* Chain this into the target line *before* expanding,
* that way we pick up any arguments to the new macro call,
* if applicable.
*/
Token **tp = &t;
t->next = tline;
expand_one_smacro(&tp);
tline = *tp; /* First token left after any macro call */
break;
}
default:
if (is_smac_param(t->type)) {
int param = smac_nparam(t->type);
nasm_assert(!tup && param < nparam);
delete_Token(t);
t = NULL;
tup = tnext;
tnext = dup_tlist_reverse(params[param], NULL);
cond_comma = false;
} else {
t->next = tline;
}
}
if (t) {
Token *endt = tline;
tline = t;
while (!cond_comma && t && t != endt) {
cond_comma = t->type != TOKEN_WHITESPACE;
t = t->next;
}
}
if (tnext) {
t = tnext;
} else {
t = tup;
tup = NULL;
}
}
if (epp) {
Token **ep = *epp;
for (t = tline; t; t = t->next)
ep = &t->next;
*epp = ep;
}
/* Expansion complete */
m->in_progress--;
return tline;
}
/*
* Count the arguments to an smacro call. Returns 0 if the token following
* is not a left paren. *tp is set to point to the final ) if non-NULL;
* it is left unchanged for the zero-argument case.
*/
static int count_smacro_args(Token *t, Token **tp)
{
int nparam;
int paren, brackets;
t = skip_white(t);
if (!tok_is(t, '('))
return 0;
paren = 1;
nparam = 1;
brackets = 0;
while (paren) {
t = t->next;
if (!t) {
nasm_nonfatal("macro call expects terminating `)'");
return 0;
}
switch (t->type) {
case ',':
if (!brackets && paren == 1)
nparam++;
break;
case '{':
brackets++;
break;
case '}':
if (brackets > 0)
brackets--;
break;
case '(':
if (!brackets)
paren++;
break;
case ')':
if (!brackets)
paren--;
break;
default:
break; /* Normal token */
}
}
if (tp)
*tp = t;
return nparam;
}
/*
* Collect the arguments to an smacro call. The size of the array must have
* been previously counted. It *is* permitted to call this with an nparam
* value that is too small for the macro in question; in that case the
* parameters are treated as missing optional arguments, even if they
* are not optional in the macro specification.
*
* *nparamp is adjusted if some arguments got merged as greedy or entered
* as optional/empty.
*
* Moves *tp to point to the final ) token.
*/
static Token **parse_smacro_args(Token **tp, int *nparamp, const SMacro *m)
{
Token **phead, **pep;
int white = 0;
int brackets = 0;
int paren;
bool bracketed = false;
bool bad_bracket = false;
int i;
enum sparmflags flags;
const struct smac_param *mparm;
Token *t = *tp;
int nparam = *nparamp;
Token **params;
/* Is it a macro or a preprocessor function? Used for diagnostics. */
const char * const mtype = m->name[0] == '%' ? "function" : "macro";
t = skip_white(t);
nasm_assert(tok_is(t, '('));
if (nparam > m->nparam) {
if (m->params[m->nparam-1].flags & SPARM_GREEDY)
*nparamp = nparam = m->nparam;
} else if (nparam < m->nparam) {
*nparamp = nparam = m->nparam; /* Missing optional arguments = empty */
}
paren = 1;
nasm_newn(params, nparam);
i = 0;
mparm = m->params;
flags = mparm->flags;
phead = pep = &params[i];
*pep = NULL;
while (paren) {
bool skip;
t = t->next;
if (!t)
nasm_nonfatal("%s `%s' call expects terminating `)'",
mtype, m->name);
skip = false;
switch (t->type) {
case TOKEN_WHITESPACE:
if (!(flags & SPARM_NOSTRIP)) {
if (brackets || *phead)
white++; /* Keep interior whitespace */
skip = true;
}
break;
case ',':
if (!brackets && paren == 1 && !(flags & SPARM_GREEDY)) {
i++;
nasm_assert(i < nparam);
phead = pep = &params[i];
*pep = NULL;
bracketed = false;
skip = true;
if (!(flags & SPARM_VARADIC)) {
mparm++;
flags = mparm->flags;
}
}
break;
case '{':
if (!bracketed) {
bracketed = !*phead && !(flags & SPARM_NOSTRIP);
skip = bracketed;
}
brackets++;
break;
case '}':
if (brackets > 0) {
if (!--brackets)
skip = bracketed;
}
break;
case '(':
if (!brackets)
paren++;
break;
case ')':
if (!brackets) {
paren--;
if (!paren) {
skip = true;
i++; /* Found last argument */
}
}
break;
default:
break; /* Normal token */
}
if (!skip) {
Token *tt;
bad_bracket |= bracketed && !brackets;
if (white) {
*pep = tt = new_White(NULL);
pep = &tt->next;
white = 0;
}
*pep = tt = dup_Token(NULL, t);
pep = &tt->next;
}
}
*tp = t;
return params;
}
/*
* Expand *one* single-line macro instance. If the first token is not
* a macro at all, it is simply copied to the output and the pointer
* advanced. tpp should be a pointer to a pointer (usually the next
* pointer of the previous token) to the first token. **tpp is updated
* to point to the first token of the expansion, and *tpp updated to
* point to the next pointer of the last token of the expansion.
*
* If the expansion is empty, *tpp will be unchanged but **tpp will
* be advanced past the macro call.
*
* Return the macro expanded, or NULL if no expansion took place.
*/
static SMacro *expand_one_smacro(Token ***tpp)
{
Token **params = NULL;
const char *mname;
Token *mstart = **tpp;
Token *tline = mstart;
SMacro *head, *m;
Token *tafter, **tep;
int nparam = 0;
if (!tline)
return NULL; /* Empty line, nothing to do */
mname = tok_text(mstart);
smacro_deadman.total--;
smacro_deadman.levels--;
if (unlikely(smacro_deadman.total < 0 || smacro_deadman.levels < 0)) {
if (unlikely(!smacro_deadman.triggered)) {
nasm_nonfatal("interminable macro recursion");
smacro_deadman.triggered = true;
}
goto not_a_macro;
} else if (tline->type == TOKEN_ID || tline->type == TOKEN_PREPROC_ID) {
head = (SMacro *)hash_findix(&smacros, mname);
} else if (tline->type == TOKEN_LOCAL_MACRO) {
Context *ctx = get_ctx(mname, &mname);
head = ctx ? (SMacro *)hash_findix(&ctx->localmac, mname) : NULL;
} else {
goto not_a_macro;
}
/*
* We've hit an identifier of some sort. First check whether the
* identifier is a single-line macro at all, then think about
* checking for parameters if necessary.
*/
list_for_each(m, head) {
if (unlikely(m->alias && ppconf.noaliases))
continue;
if (!mstrcmp(m->name, mname, m->casesense))
break;
}
if (!m) {
goto not_a_macro;
}
/* Parse parameters, if applicable */
params = NULL;
nparam = 0;
if (m->nparam == 0) {
/*
* Simple case: the macro is parameterless.
* Nothing to parse; the expansion code will
* drop the macro name token.
*/
} 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 = skip_white(tline->next);
nparam = count_smacro_args(tline, NULL);
if (!nparam)
goto not_a_macro;
/*
* Look for a macro matching in both name and parameter count.
* We already know any matches cannot be anywhere before the
* current position of "m", so there is no reason to
* backtrack.
*/
while (1) {
if (!m) {
nasm_warn(WARN_PP_MACRO_PARAMS_SINGLE|ERR_HOLD,
"single-line macro `%s' exists, "
"but not taking %d parameter%s",
mname, nparam, (nparam == 1) ? "" : "s");
goto not_a_macro;
}
if (!mstrcmp(m->name, mname, m->casesense)) {
if (nparam >= m->nparam_min &&
(m->varadic || nparam <= m->nparam))
break; /* It's good */
}
m = m->next;
}
}
if (m->in_progress && !m->recursive)
goto not_a_macro;
if (nparam) {
params = parse_smacro_args(&tline, &nparam, m);
}
tafter = tline->next; /* Skip past the macro call */
tline->next = NULL; /* Truncate mstart list at the macro call end */
tline = expand_smacro_with_params(m, mstart, params, nparam, &tep);
if (tline) {
**tpp = tline;
*tep = tafter;
*tpp = tep;
} else {
**tpp = tafter;
}
/* Don't do this until after expansion or we will clobber mname */
delete_tlist(mstart);
goto done;
/*
* No macro expansion needed; roll back to mstart (if necessary)
* and then advance to the next input token. Note that this is
* by far the common case!
*/
not_a_macro:
*tpp = &mstart->next;
m = NULL;
done:
delete_tlist_array(params, nparam);
smacro_deadman.levels++;
return m;
}
/*
* 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)
{
smacro_deadman.total = nasm_limit[LIMIT_MACRO_TOKENS];
smacro_deadman.levels = nasm_limit[LIMIT_MACRO_LEVELS];
smacro_deadman.triggered = false;
return expand_smacro_noreset(tline);
}
static Token *expand_smacro_noreset(Token *org_tline)
{
Token *tline;
bool expanded;
errhold errhold; /* Hold warning/errors during expansion */
if (!org_tline)
return NULL; /* Empty input */
/*
* 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
*/
tline = dup_Token(org_tline->next, org_tline);
/*
* Pretend that we always end up doing expansion on the first pass;
* that way %+ get processed. However, if we process %+ before the
* first pass, we end up with things like MACRO %+ TAIL trying to
* look up the macro "MACROTAIL", which we don't want.
*/
expanded = true;
while (true) {
static const struct concat_mask tmatch[] = {
{
CONCAT_ID | CONCAT_LOCAL_MACRO |
CONCAT_ENVIRON | CONCAT_PREPROC_ID, /* head */
CONCAT_ID | CONCAT_LOCAL_MACRO |
CONCAT_ENVIRON | CONCAT_PREPROC_ID |
CONCAT_NUM /* tail */
}
};
Token **tail = &tline;
/*
* We hold warnings/errors until we are done in this loop. It is
* possible for nuisance warnings to appear that disappear on later
* passes.
*/
errhold = nasm_error_hold_push();
while (*tail) /* main token loop */
expanded |= !!expand_one_smacro(&tail);
if (!expanded)
break; /* Done! */
/*
* Now scan the entire line and look for successive TOKEN_IDs
* that resulted after expansion (they can't be produced by
* tokenize()). The successive TOKEN_IDs should be concatenated.
* Also we look for %+ tokens and concatenate the tokens
* before and after them (without white spaces in between).
*/
if (!paste_tokens(&tline, tmatch, ARRAY_SIZE(tmatch), true))
break; /* Done again! */
nasm_error_hold_pop(errhold, false);
expanded = false;
}
nasm_error_hold_pop(errhold, true);
if (!tline) {
/*
* The expression expanded to empty line;
* we can't return NULL because of the "trick" above.
* Just set the line to a single WHITESPACE token.
*/
tline = new_White(NULL);
}
steal_Token(org_tline, tline);
org_tline->next = tline->next;
delete_Token(tline);
return org_tline;
}
/*
* 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 == TOKEN_ID ||
cur->next->type == TOKEN_PREPROC_ID ||
cur->next->type == TOKEN_LOCAL_MACRO ||
cur->next->type == TOKEN_NUM))
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;
}
/*
* This is called from find_mmacro_in_list() after finding a suitable macro.
*/
static MMacro *use_mmacro(MMacro *m, int *nparamp, Token ***paramsp)
{
int nparam = *nparamp;
Token **params = *paramsp;
/*
* This one is right. Just check if cycle removal
* prohibits us using it before we actually celebrate...
*/
if (m->in_progress > m->max_depth) {
if (m->max_depth > 0) {
/* Document this properly when recursive mmacros re-implemented */
nasm_warn(WARN_OTHER,
"reached maximum recursion depth of %"PRId32,
m->max_depth);
}
nasm_free(params);
*nparamp = 0;
*paramsp = NULL;
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) {
int newnparam = m->nparam_min + m->ndefs;
params = nasm_realloc(params, sizeof(*params) * (newnparam+2));
memcpy(&params[nparam+1], &m->defaults[nparam+1-m->nparam_min],
(newnparam - nparam) * sizeof(*params));
nparam = newnparam;
}
/*
* 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;
/*
* If nparam was adjusted above, make sure the list is still
* NULL-terminated.
*/
params[nparam+1] = NULL;
/* Done! */
*paramsp = params;
*nparamp = nparam;
return m;
}
/*
* Search a macro list and try to find a match. If matching, call
* use_mmacro() to set up the macro call. m points to the list of
* search, which is_mmacro() sets to the first *possible* match.
*/
static MMacro *
find_mmacro_in_list(MMacro *m, const char *finding,
int *nparamp, Token ***paramsp)
{
int nparam = *nparamp;
while (m) {
if (m->nparam_min <= nparam
&& (m->plus || nparam <= m->nparam_max)) {
/*
* This one matches, use it.
*/
return use_mmacro(m, nparamp, paramsp);
}
/*
* Otherwise search for the next one with a name match.
*/
list_for_each(m, m->next) {
if (!mstrcmp(m->name, finding, m->casesense))
break;
}
}
return NULL;
}
/*
* 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 == TOKEN_ID, so the putative macro
* name is easy to find.
*/
static MMacro *is_mmacro(Token * tline, int *nparamp, Token ***paramsp)
{
MMacro *head, *m, *found;
Token **params, **comma;
int raw_nparam, nparam;
const char *finding;
bool empty_args;
*nparamp = 0;
*paramsp = NULL;
if (!tok_macro_id(tline))
return NULL;
finding = tok_text(tline);
empty_args = !tline->next;
head = (MMacro *) hash_findix(&mmacros, finding);
/*
* Efficiency: first we see if any macro exists with the given
* name which isn't already excluded by macro cycle removal.
* (The cycle removal test here helps optimize the case of wrapping
* instructions, and is cheap to do here.)
*
* 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.
*/
list_for_each(m, head) {
if (!mstrcmp(m->name, finding, m->casesense) &&
(m->in_progress != 1 || m->max_depth > 0))
break; /* Found something that needs consideration */
}
if (!m)
return NULL;
/*
* OK, we have a potential macro. Count and demarcate the
* parameters.
*/
comma = count_mmac_params(tline->next, nparamp, paramsp);
raw_nparam = *nparamp;
/*
* Search for an exact match. This cannot come *before* the m
* found in the list search before, so we can start there.
*
* If found is NULL and *paramsp has been cleared, then we
* encountered an error for which we have already issued a
* diagnostic, so we should not proceed.
*/
found = find_mmacro_in_list(m, finding, nparamp, paramsp);
if (!*paramsp)
return NULL;
nparam = *nparamp;
params = *paramsp;
/*
* Special weirdness: in NASM < 2.15, an expansion of
* *only* whitespace, as can happen during macro expansion under
* certain circumstances, is counted as zero arguments for the
* purpose of %0, but one argument for the purpose of macro
* matching! In particular, this affects:
*
* foobar %1
*
* ... with %1 being empty; this would call the one-argument
* version of "foobar" with an empty argument, equivalent to
*
* foobar {%1}
*
* ... except that %0 would be set to 0 inside foobar, even if
* foobar is declared with "%macro foobar 1" or equivalent!
*
* The proper way to do that is to define "%macro foobar 0-1".
*
* To be compatible without doing something too stupid, try to
* match a zero-argument macro first, but if that fails, try
* for a one-argument macro with the above behavior.
*
* Furthermore, NASM < 2.15 will match stripping a tailing empty
* argument, but in that case %0 *does* reflect that this argument
* have been stripped; this is handled in count_mmac_params().
*
* To disable these insane legacy behaviors, use:
*
* %pragma preproc sane_empty_expansion yes
*/
if (!ppconf.sane_empty_expansion) {
if (!found) {
if (raw_nparam == 0 && !empty_args) {
/*
* A single all-whitespace parameter as the only thing?
* Look for a one-argument macro, but don't adjust
* *nparamp.
*/
int bogus_nparam = 1;
params[2] = NULL;
found = find_mmacro_in_list(m, finding, &bogus_nparam, paramsp);
} else if (raw_nparam > 1 && comma) {
Token *comma_tail = *comma;
/*
* Drop the terminal argument and try again.
* If we fail, we need to restore the comma to
* preserve tlist.
*/
*comma = NULL;
*nparamp = raw_nparam - 1;
found = find_mmacro_in_list(m, finding, nparamp, paramsp);
if (found)
delete_tlist(comma_tail);
else
*comma = comma_tail;
}
if (!*paramsp)
return NULL;
} else if (comma) {
delete_tlist(*comma);
*comma = NULL;
if (raw_nparam > found->nparam_min &&
raw_nparam <= found->nparam_min + found->ndefs) {
/* Replace empty argument with default parameter */
params[raw_nparam] =
found->defaults[raw_nparam - found->nparam_min];
} else if (raw_nparam > found->nparam_max && found->plus) {
/* Just drop the comma, don't adjust argument count */
} else {
/* Drop argument. This may cause nparam < nparam_min. */
params[raw_nparam] = NULL;
*nparamp = nparam = raw_nparam - 1;
}
}
if (found) {
if (raw_nparam < found->nparam_min ||
(raw_nparam > found->nparam_max && !found->plus)) {
nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY,
"improperly calling multi-line macro `%s' with %d parameters",
found->name, raw_nparam);
} else if (comma) {
nasm_warn(WARN_PP_MACRO_PARAMS_LEGACY,
"dropping trailing empty parameter in call to multi-line macro `%s'", found->name);
}
}
}
/*
* After all that, we didn't find one with the right number of
* parameters. Issue a warning, and fail to expand the macro.
*/
if (found)
return found;
nasm_warn(WARN_PP_MACRO_PARAMS_MULTI,
"multi-line macro `%s' exists, but not taking %d parameter%s",
finding, nparam, (nparam == 1) ? "" : "s");
nasm_free(*paramsp);
return NULL;
}
#if 0
/*
* Save MMacro invocation specific fields in
* preparation for a recursive macro expansion
*/
static void push_mmacro(MMacro *m)
{
MMacroInvocation *i;
i = nasm_malloc(sizeof(MMacroInvocation));
i->prev = m->prev;
i->params = m->params;
i->iline = m->iline;
i->nparam = m->nparam;
i->rotate = m->rotate;
i->paramlen = m->paramlen;
i->unique = m->unique;
i->condcnt = m->condcnt;
m->prev = i;
}
/*
* Restore MMacro invocation specific fields that were
* saved during a previous recursive macro expansion
*/
static void pop_mmacro(MMacro *m)
{
MMacroInvocation *i;
if (m->prev) {
i = m->prev;
m->prev = i->prev;
m->params = i->params;
m->iline = i->iline;
m->nparam = i->nparam;
m->rotate = i->rotate;
m->paramlen = i->paramlen;
m->unique = i->unique;
m->condcnt = i->condcnt;
nasm_free(i);
}
}
#endif
/*
* List an mmacro call with arguments (-Lm option)
*/
static void list_mmacro_call(const MMacro *m)
{
const char prefix[] = " ;;; [macro] ";
size_t namelen, size;
char *buf, *p;
unsigned int i;
const Token *t;
namelen = strlen(m->iname);
size = namelen + sizeof(prefix); /* Includes final null (from prefix) */
for (i = 1; i <= m->nparam; i++) {
int j = 0;
size += 3; /* Braces and space/comma */
list_for_each(t, m->params[i]) {
if (j++ >= m->paramlen[i])
break;
size += (t->type == TOKEN_WHITESPACE) ? 1 : t->len;
}
}
buf = p = nasm_malloc(size);
p = mempcpy(p, prefix, sizeof(prefix) - 1);
p = mempcpy(p, m->iname, namelen);
*p++ = ' ';
for (i = 1; i <= m->nparam; i++) {
int j = 0;
*p++ = '{';
list_for_each(t, m->params[i]) {
if (j++ >= m->paramlen[i])
break;
p = mempcpy(p, tok_text(t), t->len);
}
*p++ = '}';
*p++ = ',';
}
*--p = '\0'; /* Replace last delimiter with null */
lfmt->line(LIST_MACRO, -1, buf);
nasm_free(buf);
}
/*
* Collect information about macro invocations for the benefit of
* the debugger. During execution we create a reverse list; before
* calling the backend reverse it to definition/invocation order just
* to be nicer. [XXX: not implemented yet]
*/
struct debug_macro_inv *debug_current_macro;
/* Get/create a addr structure for a seg:inv combo */
static struct debug_macro_addr *
debug_macro_get_addr_inv(int32_t seg, struct debug_macro_inv *inv)
{
struct debug_macro_addr *addr;
nasm_static_assert(offsetof(struct debug_macro_addr, tree) == 0);
if (likely(seg == inv->lastseg))
return inv->addr.last;
inv->lastseg = seg;
addr = (struct debug_macro_addr *)
rb_search_exact(inv->addr.tree, seg);
if (unlikely(!addr)) {
nasm_new(addr);
addr->tree.key = seg;
inv->addr.tree = rb_insert(inv->addr.tree, &addr->tree);
inv->naddr++;
if (inv->up)
addr->up = debug_macro_get_addr_inv(seg, inv->up);
}
return inv->addr.last = addr;
}
/* Get/create an addr structure for a seg in debug_current_macro */
struct debug_macro_addr *debug_macro_get_addr(int32_t seg)
{
return debug_macro_get_addr_inv(seg, debug_current_macro);
}
static struct debug_macro_info dmi;
static struct debug_macro_inv_list *current_inv_list = &dmi.inv;
static void debug_macro_start(MMacro *m, struct src_location where)
{
struct debug_macro_def *def = m->dbg.def;
struct debug_macro_inv *inv;
nasm_assert(!m->dbg.inv);
/* First invocation? Need to create a def structure */
if (unlikely(!def)) {
nasm_new(def);
def->name = nasm_strdup(m->name);
def->where = m->where;
def->next = dmi.def.l;
dmi.def.l = def;
dmi.def.n++;
m->dbg.def = def;
}
nasm_new(inv);
inv->lastseg = NO_SEG;
inv->where = where;
inv->up = debug_current_macro;
inv->next = current_inv_list->l;
inv->def = def;
current_inv_list->l = inv;
current_inv_list->n++;
current_inv_list = &inv->down;
def->ninv++;
m->dbg.inv = inv;
debug_current_macro = inv;
}
static void debug_macro_end(MMacro *m)
{
struct debug_macro_inv *inv, *minv;
MMacro *mm = istk->mstk.mmac;
/* Not actually ending the current macro */
if (m->mstk.mmac == m)
return;
inv = m->dbg.inv;
nasm_assert(inv == debug_current_macro);
list_reverse(inv->down.l);
m->dbg.inv = NULL;
inv = inv->up;
minv = mm ? mm->dbg.inv : NULL;
nasm_assert(inv == minv);
debug_current_macro = inv;
if (inv)
current_inv_list = &inv->down;
else
current_inv_list = &dmi.inv;
}
static void free_debug_macro_addr_tree(struct rbtree *tree)
{
struct rbtree *left, *right;
nasm_static_assert(offsetof(struct debug_macro_addr,tree) == 0);
if (!tree)
return;
left = rb_left(tree);
right = rb_right(tree);
nasm_free(tree);
free_debug_macro_addr_tree(left);
free_debug_macro_addr_tree(right);
}
static void free_debug_macro_inv_list(struct debug_macro_inv *inv)
{
struct debug_macro_inv *itmp;
if (!inv)
return;
list_for_each_safe(inv, itmp, inv) {
free_debug_macro_inv_list(inv->down.l);
free_debug_macro_addr_tree(inv->addr.tree);
nasm_free(inv);
}
}
static void free_debug_macro_info(void)
{
struct debug_macro_def *def, *dtmp;
list_for_each_safe(def, dtmp, dmi.def.l)
nasm_free(def);
free_debug_macro_inv_list(dmi.inv.l);
nasm_zero(dmi);
}
static void debug_macro_output(void)
{
list_reverse(dmi.inv.l);
dfmt->debug_mmacros(&dmi);
free_debug_macro_info();
}
/*
* 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;
bool dont_prepend = false;
Token **params, *t, *tt;
MMacro *m;
Line *l, *ll;
int i, *paramlen;
const char *mname;
int nparam = 0;
t = tline;
t = skip_white(t);
if (!tok_macro_id(t))
return 0;
m = is_mmacro(t, &nparam, &params);
if (m) {
mname = tok_text(t);
} else {
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_white(t))
last = t, t = t->next;
if (tok_is(t, ':')) {
dont_prepend = true;
last = t, t = t->next;
if (tok_white(t))
last = t, t = t->next;
}
m = is_mmacro(t, &nparam, &params);
if (!m)
return 0;
last->next = NULL;
mname = tok_text(t);
tline = t;
}
if (unlikely(mmacro_deadman.total >= nasm_limit[LIMIT_MMACROS] ||
mmacro_deadman.levels >= nasm_limit[LIMIT_MACRO_LEVELS])) {
if (!mmacro_deadman.triggered) {
nasm_nonfatal("interminable multiline macro recursion");
mmacro_deadman.triggered = true;
}
return 0;
}
mmacro_deadman.total++;
mmacro_deadman.levels++;
/*
* Fix up the parameters: this involves stripping leading and
* trailing whitespace and stripping braces if they are present.
*/
nasm_newn(paramlen, nparam+1);
for (i = 1; i < nparam+1 && (t = params[i]); i++) {
bool braced = false;
int brace = 0;
int white = 0;
bool comma = !m->plus || i < nparam;
t = skip_white(t);
if (tok_is(t, '{')) {
t = t->next;
brace = 1;
braced = true;
comma = false;
}
params[i] = t;
for (; t; t = t->next) {
if (tok_white(t)) {
white++;
continue;
}
switch(t->type) {
case ',':
if (comma && !brace)
goto endparam;
break;
case '{':
brace++;
break;
case '}':
brace--;
if (braced && !brace) {
paramlen[i] += white;
goto endparam;
}
break;
default:
break;
}
paramlen[i] += white + 1;
white = 0;
}
endparam:
;
}
/*
* 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 and give the right semantics for
* nested mmacros.
*
* First, push an end marker on to istk->expansion, mark this
* macro as in progress, and set up its invocation-specific
* variables.
*/
nasm_new(ll);
ll->next = istk->expansion;
ll->finishes = get_mmacro(m);
ll->where = istk->where;
istk->expansion = ll;
/*
* Save the previous MMacro expansion in the case of
* macro recursion
*/
#if 0
if (m->max_depth && m->in_progress)
push_mmacro(m);
#endif
m->in_progress++;
m->params = params;
m->iline = tline;
m->iname = nasm_strdup(mname);
m->nparam = nparam;
m->rotate = 0;
m->paramlen = paramlen;
m->unique = unique++;
m->condcnt = 0;
m->mstk = istk->mstk; /* Inherits refcounts */
istk->mstk.mstk = get_mmacro(m);
istk->mstk.mmac = get_mmacro(m);
list_for_each(l, m->expansion) {
nasm_new(ll);
ll->next = istk->expansion;
istk->expansion = ll;
ll->first = dup_tlist(l->first, NULL);
ll->where = l->where;
}
/*
* If we had a label, and this macro definition does not include
* a %00, push it on as the first line of, ot
* the macro expansion.
*/
if (label) {
/*
* We had a label. If this macro contains an %00 parameter,
* save the value as a special parameter (which is what it
* is), otherwise push it as the first line of the macro
* expansion.
*/
if (m->capture_label) {
params[0] = dup_Token(NULL, label);
paramlen[0] = 1;
delete_tlist(startline);
} else {
nasm_new(ll);
ll->finishes = NULL;
ll->next = istk->expansion;
istk->expansion = ll;
ll->first = startline;
ll->where = istk->where;
if (!dont_prepend) {
while (label->next)
label = label->next;
label->next = tt = make_tok_char(NULL, ':');
}
}
}
istk->nolist += !!(m->nolist & NL_LIST);
istk->noline += !!(m->nolist & NL_LINE);
if (!istk->nolist) {
if (list_option('m'))
list_mmacro_call(m);
lfmt->uplevel(LIST_MACRO, 0);
if (ppdbg & PDBG_MMACROS)
debug_macro_start(m, src_where());
}
if (!istk->noline)
src_macro_push(get_mmacro(m), istk->where);
return 1;
}
/*
* This function decides if an error message should be suppressed.
* It will never be called with a severity level of ERR_FATAL or
* higher.
*/
bool pp_suppress_error(errflags severity)
{
/*
* If we're in a dead branch of IF or something like it, ignore the error.
* However, because %else etc are evaluated in the state context
* of the previous branch, errors might get lost:
* %if 0 ... %else trailing garbage ... %endif
* So %else etc should set the ERR_PP_PRECOND flag.
*/
if (istk && istk->conds &&
((severity & ERR_PP_PRECOND) ?
istk->conds->state == COND_NEVER :
!emitting(istk->conds->state)))
return true;
return false;
}
static Token *
stdmac_file(const SMacro *s, Token **params, int nparams)
{
const char *fname = src_get_fname();
(void)s;
(void)params;
(void)nparams;
return fname ? make_tok_qstr(NULL, fname) : NULL;
}
static Token *
stdmac_line(const SMacro *s, Token **params, int nparams)
{
(void)s;
(void)params;
(void)nparams;
return make_tok_num(NULL, src_get_linnum());
}
static Token *
stdmac_bits(const SMacro *s, Token **params, int nparams)
{
(void)s;
(void)params;
(void)nparams;
return make_tok_num(NULL, globl.bits);
}
static Token *
stdmac_ptr(const SMacro *s, Token **params, int nparams)
{
(void)s;
(void)params;
(void)nparams;
switch (globl.bits) {
case 16:
return new_Token(NULL, TOKEN_ID, "word", 4);
case 32:
return new_Token(NULL, TOKEN_ID, "dword", 5);
case 64:
return new_Token(NULL, TOKEN_ID, "qword", 5);
default:
panic();
}
}
static Token *
stdmac_default(const SMacro *s, Token **params, int nparam)
{
Token *t = NULL;
(void)s;
(void)params;
(void)nparam;
t = new_Token(t, TOKEN_ID, globl.rel & EAF_NOTFSGS ? "rel" : "abs", 3);
t = make_tok_char(t, ',');
t = new_Token(t, TOKEN_ID, "fs", 2);
t = make_tok_char(t, ':');
t = new_Token(t, TOKEN_ID, globl.rel & EAF_FS ? "rel" : "abs", 3);
t = make_tok_char(t, ',');
t = new_Token(t, TOKEN_ID, "gs", 2);
t = make_tok_char(t, ':');
t = new_Token(t, TOKEN_ID, globl.rel & EAF_GS ? "rel" : "abs", 3);
t = make_tok_char(t, ',');
t = new_Token(t, TOKEN_ID, globl.bnd ? "bnd" : "nobnd", 0);
return t;
}
/* %is...() function macros */
static Token *
stdmac_is(const SMacro *s, Token **params, int nparams)
{
int retval;
struct Token *pline = params[0];
(void)nparams;
params[0] = NULL; /* Don't free this later */
retval = if_condition(pline, s->expandpvt.u, s->name) == COND_IF_TRUE;
return make_tok_num(NULL, retval);
}
/*
* Join all expanded macro arguments with commas, e.g. %eval().
* Remember that this needs to output the tokens in reverse order.
*
* This can also be used when only single argument is already ready
* to be emitted, e.g. %str().
*/
static Token *
stdmac_join(const SMacro *s, Token **params, int nparams)
{
struct Token *tline = NULL;
int i;
(void)s;
for (i = 0; i < nparams; i++) {
Token *t, *ttmp;
if (i)
tline = make_tok_char(tline, ',');
list_for_each_safe(t, ttmp, params[i]) {
t->next = tline;
tline = t;
}
/* Avoid freeing the tokens we "stole" */
params[i] = NULL;
}
return tline;
}
/* %strcat() function */
static Token *
stdmac_strcat(const SMacro *s, Token **params, int nparams)
{
int i;
size_t len = 0;
char *str, *p;
Token *t;
(void)s;
for (i = 0; i < nparams; i++) {
unquote_token(params[i]);
len += params[i]->len;
}
p = str = nasm_malloc(len+1);
for (i = 0; i < nparams; i++) {
p = mempcpy(p, tok_text(params[i]), params[i]->len);
}
*p = '\0';
t = make_tok_qstr_len(NULL, str, p - str);
nasm_free(str);
return t;
}
/* %hs2b() function */
static Token *
stdmac_hs2b(const SMacro *s, Token **params, int nparams)
{
int i;
size_t len = 0;
char *str, *q;
Token *t;
(void)s;
for (i = 0; i < nparams; i++) {
unquote_token(params[i]);
len += (params[i]->len + 1) >> 1; /* Maximum possible */
}
q = str = nasm_malloc(len+1);
for (i = 0; i < nparams; i++) {
const char *p = tok_text(params[i]);
unsigned int j;
unsigned int len = params[i]->len;
int v = -1;
for (j = 0; j < len; j++) {
unsigned int hv = nasm_hexval(*p++);
if (hv > 15) {
/* Separator character or end of string */
if (v >= 0)
*q++ = v;
v = -1;
} else {
if (v >= 0) {
*q++ = (v << 4) + hv;
v = -1;
} else {
v = hv;
}
}
}
/* Partial byte at the end? */
if (v >= 0)
*q++ = v;
}
*q = '\0';
t = make_tok_qstr_len(NULL, str, q - str);
nasm_free(str);
return t;
}
/* %b2hs() function */
static Token *
stdmac_b2hs(const SMacro *s, Token **params, int nparams)
{
const char * const dchars = nasm_digit_chars(false);
const char *p;
const char *sep;
uint8_t b;
char *str, *q;
size_t bytes, len, seplen;
size_t i;
Token *t;
(void)s;
(void)nparams;
p = unquote_token(params[0]);
if (!params[0]->len)
return make_tok_qstr_len(NULL, "", 0);
sep = unquote_token(params[1]);
bytes = params[0]->len;
seplen = params[1]->len;
len = (bytes << 1) + (seplen * (bytes-1));
q = str = nasm_malloc(len+1);
b = *p++;
*q++ = dchars[b >> 4];
*q++ = dchars[b & 15];
for (i = 1; i < bytes; i++) {
if (seplen)
q = mempcpy(q, sep, seplen);
b = *p++;
*q++ = dchars[b >> 4];
*q++ = dchars[b & 15];
}
*q = '\0';
t = make_tok_qstr_len(NULL, str, q - str);
nasm_free(str);
return t;
}
/* %substr() function */
static Token *
stdmac_substr(const SMacro *s, Token **params, int nparams)
{
int64_t start, count;
(void)nparams;
(void)s;
start = get_tok_num(params[1], NULL);
count = get_tok_num(params[2], NULL);
return pp_substr_common(params[0], start, count);
}
/* %ord() function */
static Token *
stdmac_ord(const SMacro *s, Token **params, int nparams)
{
int64_t start, count;
const uint8_t *txt;
Token *t;
(void)nparams;
(void)s;
start = get_tok_num(params[1], NULL);
count = get_tok_num(params[2], NULL);
txt = (const uint8_t *)pp_get_substr(params[0], start, &count);
if (!count)
return NULL;
t = make_tok_num(NULL, *txt++);
while (--count) {
t = make_tok_char(t, ',');
t = make_tok_num(t, *txt++);
}
return t;
}
/* %chr() function */
static Token *
stdmac_chr(const SMacro *s, Token **params, int nparams)
{
int i;
char *buf = nasm_malloc(nparams);
char *p = buf;
Token *t;
(void)s;
for (i = 0; i < nparams; i++) {
/* Skip empty parameters! */
if (params[i]) {
*p++ = get_tok_num(params[i], NULL);
}
}
t = make_tok_qstr_len(NULL, buf, p - buf);
nasm_free(buf);
return t;
}
/* %strlen() function */
static Token *
stdmac_strlen(const SMacro *s, Token **params, int nparams)
{
(void)nparams;
(void)s;
unquote_token(params[0]);
return make_tok_num(NULL, params[0]->len);
}
/* %tok() function */
static Token *
stdmac_tok(const SMacro *s, Token **params, int nparams)
{
(void)nparams;
(void)s;
return reverse_tokens(tokenize(unquote_token_cstr(params[0])));
}
/* %sel() */
static Token *
stdmac_sel(const SMacro *s, Token **params, int nparams)
{
int64_t which;
/*
* params[0] will have been generated by make_tok_num.
*/
which = get_tok_num(params[0], NULL);
if (unlikely(which < 1)) {
nasm_warn(WARN_PP_SEL_RANGE,
"%s(%"PRId64") is not a valid selector", s->name, which);
return NULL;
} else if (unlikely(which >= nparams)) {
nasm_warn(WARN_PP_SEL_RANGE,
"%s(%"PRId64") exceeds the number of arguments",
s->name, which);
return NULL;
}
return new_Token(NULL, tok_smac_param(which), "", 0);
}
/* %cond() */
static Token *
stdmac_cond(const SMacro *s, Token **params, int nparams)
{
int64_t which;
(void)s;
(void)params;
/*
* params[0] will have been generated by make_tok_num.
*/
which = get_tok_num(params[0], NULL);
/* Booleanize: true -> 1, false -> 2 (else) */
which = which ? 1 : 2;
if (which >= nparams) {
/* false, and no else clause */
return NULL;
}
return new_Token(NULL, tok_smac_param(which), "", 0);
}
/* %selbits() */
static Token *
stdmac_selbits(const SMacro *s, Token **params, int nparams)
{
int which = ilog2_32(globl.bits)-4;
(void)s;
(void)params;
if (nparams <= which)
which = nparams - 1;
return new_Token(NULL, tok_smac_param(which), "", 0);
}
/* %count() function */
static Token *
stdmac_count(const SMacro *s, Token **params, int nparams)
{
(void)s;
(void)params;
return make_tok_num(NULL, nparams);
}
/* %num() function */
static Token *
stdmac_num(const SMacro *s, Token **params, int nparam)
{
int64_t parm[3];
uint64_t n;
int64_t dparm, bparm;
const int maxlen = 256;
char numbuf[256+5];
char *p;
char decorate;
int i;
(void)nparam;
for (i = 0; i < (int)ARRAY_SIZE(parm); i++)
parm[i] = get_tok_num(params[i], NULL);
n = parm[0];
dparm = parm[1];
bparm = parm[2];
decorate = 0;
if (bparm < 0) {
bparm = -bparm;
switch (bparm) {
case 2:
decorate = 'b';
break;
case 8:
decorate = 'q';
break;
case 10:
decorate = 'd';
break;
case 16:
decorate = 'x';
break;
default:
bparm = -bparm; /* Error out below */
break;
}
}
if (bparm < 2 || bparm > NUMSTR_MAXBASE) {
nasm_nonfatal("invalid base %"PRId64" in %s()\n", bparm, s->name);
return NULL;
}
if (dparm < -maxlen || dparm > maxlen) {
nasm_nonfatal("digit count %"PRId64" specified to %s() too large",
dparm, s->name);
dparm = -1;
}
/* Are we supposed to generate an empty string for zero? */
if (!dparm && !n)
decorate = 0;
p = numbuf;
*p++ = '\'';
if (decorate) {
*p++ = '0';
*p++ = decorate;
}
p += numstr(p, maxlen, n, dparm, bparm, false);
*p++ = '\'';
*p = '\0';
return new_Token(NULL, TOKEN_STR, numbuf, p - numbuf);
}
/* %abs() function */
static Token *
stdmac_abs(const SMacro *s, Token **params, int nparam)
{
char numbuf[24];
int len;
int64_t v;
uint64_t u;
(void)s;
(void)nparam;
v = get_tok_num(params[0], NULL);
u = v < 0 ? -v : v;
/*
* Don't use make_tok_num() here, to make sure we don't emit
* a minus sign for the case of v = -2^63
*/
len = snprintf(numbuf, sizeof numbuf, "%"PRIu64, u);
return new_Token(NULL, TOKEN_NUM, numbuf, len);
}
/* %map() function */
static Token *
stdmac_map(const SMacro *s, Token **params, int nparam)
{
const char *mname, *ctxname;
SMacro *smac;
Context *ctx;
Token *t, *tline, *mstart;
int i;
Token *fixargs;
int fixparams; /* Number of fixed parameters */
int mparams; /* Number of variable parameters */
int tparams; /* Total number of parameters */
int greedify; /* Number of parameters that must be joined */
Token **fparam; /* Fixed parameters */
Token **cparam; /* Final list of macro call parameters */
t = params[0];
mname = get_id_noskip(&t, "%map");
if (!mname)
return NULL;
mstart = t;
fixargs = NULL;
fixparams = 0;
mparams = 1;
t = skip_white(t->next);
if (tok_is(t, ':')) {
fixargs = t->next;
fixparams = count_smacro_args(fixargs, &t);
t = skip_white(t->next);
if (tok_is(t, ':')) {
struct ppscan pps;
struct tokenval tokval;
expr *evalresult;
Token *ep;
pps.tptr = ep = zap_white(expand_smacro_noreset(t->next));
t->next = NULL;
pps.ntokens = -1;
tokval.t_type = TOKEN_INVALID;
evalresult = evaluate(ppscan, &pps, &tokval, NULL, true, NULL);
delete_tlist(ep);
if (!evalresult || tokval.t_type) {
nasm_nonfatal("invalid expression in parameter count for `%s' in function %s",
mname, s->name);
return NULL;
} else if (!is_simple(evalresult)) {
nasm_nonfatal("non-constant expression in parameter count for `%s' in function %s",
mname, s->name);
return NULL;
}
mparams = reloc_value(evalresult);
if (mparams < 1) {
nasm_nonfatal("invalid parameter count for `%s' in function %s",
mname, s->name);
return NULL;
}
}
}
nparam--;
params++;
if (nparam % mparams) {
nasm_nonfatal("%s expected a multiple of %d expansion parameters, got %d\n",
s->name, mparams, nparam);
}
tparams = fixparams + mparams;
ctx = get_ctx(mname, &ctxname);
if (!smacro_defined(ctx, ctxname, tparams, &smac, true, false)
|| smac->nparam == 0 || (smac->in_progress && !smac->recursive)) {
nasm_nonfatal("macro `%s' taking %d parameter%s not found in function %s",
mname, tparams, tparams == 1 ? "" : "s", s->name);
return NULL;
}
if (nparam < mparams)
return NULL; /* Empty expansion */
fparam = NULL;
if (fixparams) {
int nfp = fixparams;
fparam = parse_smacro_args(&fixargs, &nfp, smac);
if (nfp < fixparams) {
fixparams = nfp;
tparams = fixparams + mparams;
}
}
greedify = 0;
if (unlikely(tparams > smac->nparam)) {
if (smac->params[smac->nparam-1].flags & SPARM_GREEDY)
greedify = smac->nparam;
}
nasm_newn(cparam, tparams);
tline = NULL;
while (1) {
int xparams;
for (i = 0; i < fixparams; i++) {
/* expand_smacro_with_params() is allowed to clobber the
* parameter array, so we need to give it its own copy.
*/
cparam[i] = dup_tlist(fparam[i], NULL);
}
for (i = fixparams; i < tparams; i++) {
cparam[i] = *params;
*params = NULL; /* Taking over ownership */
params++;
}
if (unlikely(greedify)) {
/* Need to re-concatenate some number of arguments as
comma-separated lists... */
int i;
Token **tp = &cparam[greedify-1];
while (*tp)
tp = &(*tp)->next;
for (i = greedify; i < tparams; i++) {
*tp = make_tok_char(NULL, ',');
tp = steal_tlist(cparam[i], &(*tp)->next);
cparam[i] = NULL;
}
xparams = greedify;
} else {
xparams = tparams;
}
t = expand_smacro_with_params(smac, mstart, cparam, xparams, NULL);
if (t) {
Token *rt = reverse_tokens(t);
t->next = tline;
tline = rt;
}
for (i = 0; i < xparams; i++)
delete_tlist(cparam[i]);
nparam -= mparams;
if (nparam < mparams)
break;
tline = make_tok_char(tline, ',');
}
nasm_free(fparam);
nasm_free(cparam);
return tline;
}
/* %pathsearch() function */
static Token *
stdmac_pathsearch(const SMacro *s, Token **params, int nparam)
{
(void)nparam;
return pp_do_pathsearch(&params[0], s->name);
}
/* %depend() function */
static Token *
stdmac_depend(const SMacro *s, Token **params, int nparam)
{
(void)nparam;
return pp_do_depend(&params[0], s->name);
}
static Token *
stdmac_realpath(const SMacro *s, Token **params, int nparam)
{
const struct file_hash_entry *fhe;
Token *t, *ot;
(void)nparam;
t = tlist_filename(&params[0], &ot, s->name);
if (!t)
return NULL;
inc_fopen(tok_text(t), NULL, &fhe, INC_PROBE|INC_EXACT, NF_BINARY);
if (fhe) {
delete_Token(t);
return make_tok_qstr(NULL, fhe->full->path);
} else {
return steal_Token(t, ot);
}
}
static Token *
stdmac_null(const SMacro *s, Token **params, int nparam)
{
(void)s;
(void)params;
(void)nparam;
return NULL; /* Empty expansion */
}
#if 0 /* Disabled, because they seem to be expanded inappropriately */
static Token *
stdmac_user_error(const SMacro *s, Token **params, int nparam)
{
(void)nparam;
user_error(s->expandpvt.u, &params[0]);
return NULL; /* Always expands to empty */
}
#endif
static Token *
stdmac_find(const SMacro *s, Token **params, int nparam)
{
bool casesense = s->expandpvt.u;
int i;
int found = 0;
const char *ref = unquote_token(params[0]);
size_t rlen = params[0]->len;
for (i = 1; i < nparam; i++) {
const char *cmp;
size_t clen;
/*
* This is done here rather than by declaring it in the
* argument flags, so that we don't expand ignored arguments
* (argument short circuiting.)
*/
params[i] = expand_sparm_str(params[i], SPARM_STR|SPARM_CONDQUOTE);
cmp = unquote_token(params[i]);
clen = params[i]->len;
if (rlen == clen && !mmemcmp(ref, cmp, rlen, casesense)) {
found = i;
break;
}
}
return make_tok_num(NULL, found);
}
/*
* Wrapper around define_smacro() which also checks to see if it is
* a preprocessor directive, so that pp_op_may_be_function[] needs to
* be set.
*/
static SMacro *define_magic(const char *mname, bool casesense, SMacro *tmpl)
{
enum preproc_token op = pp_get_directive(mname);
if (op != PP_invalid)
pp_op_may_be_function[op] = true;
/* Magic functions can be recursive */
if (tmpl && tmpl->nparam && tmpl->expand)
tmpl->recursive = true;
return define_smacro(mname, casesense, NULL, tmpl);
}
/*
* Simple standard magic macros and functions.
* Note that preprocessor functions (but obviously not zero-argument macros)
* are allowed to recurse.
*/
static void pp_add_magic_simple(void)
{
struct magic_macros {
const char *name;
bool casesense;
int nparam;
enum sparmflags flags;
ExpandSMacro func;
};
static const struct magic_macros magic_macros[] = {
{ "__?FILE?__", true, 0, 0, stdmac_file },
{ "__?LINE?__", true, 0, 0, stdmac_line },
{ "__?BITS?__", true, 0, 0, stdmac_bits },
{ "__?PTR?__", true, 0, 0, stdmac_ptr },
{ "__?DEFAULT?__", true, 0, 0, stdmac_default },
{ "%abs", false, 1, SPARM_EVAL, stdmac_abs },
{ "%chr", false, 1, SPARM_EVAL|SPARM_OPTIONAL|SPARM_VARADIC, stdmac_chr },
{ "%count", false, 1, SPARM_VARADIC, stdmac_count },
{ "%depend", false, 1, SPARM_PLAIN, stdmac_depend },
{ "%eval", false, 1, SPARM_EVAL|SPARM_VARADIC, stdmac_join },
{ "%hs2b", false, 1, SPARM_STR|SPARM_CONDQUOTE|SPARM_VARADIC, stdmac_hs2b },
{ "%map", false, 1, SPARM_VARADIC, stdmac_map },
{ "%null", false, 1, SPARM_GREEDY, stdmac_null },
{ "%pathsearch", false, 1, SPARM_PLAIN, stdmac_pathsearch },
{ "%realpath", false, 1, SPARM_PLAIN, stdmac_realpath },
{ "%selbits", false, 1, SPARM_PLAIN|SPARM_VARADIC, stdmac_selbits },
{ "%str", false, 1, SPARM_GREEDY|SPARM_STR, stdmac_join },
{ "%strcat", false, 1, SPARM_STR|SPARM_CONDQUOTE|SPARM_VARADIC, stdmac_strcat },
{ "%strlen", false, 1, SPARM_STR|SPARM_CONDQUOTE, stdmac_strlen },
{ "%tok", false, 1, SPARM_STR|SPARM_CONDQUOTE, stdmac_tok },
}, *m;
SMacro tmpl;
nasm_zero(tmpl);
array_for_each(m, magic_macros) {
tmpl.nparam = m->nparam;
tmpl.expand = m->func;
if (m->nparam) {
int i;
enum sparmflags flags = m->flags;
nasm_newn(tmpl.params, m->nparam);
for (i = m->nparam-1; i >= 0; i--) {
tmpl.params[i].flags = flags;
/* These flags for the last arg only */
flags &= ~(SPARM_GREEDY|SPARM_VARADIC|SPARM_OPTIONAL);
}
}
define_magic(m->name, m->casesense, &tmpl);
}
}
/* %is...() macro functions */
static void pp_add_magic_isfunc(void)
{
SMacro tmpl;
enum preproc_token pt;
char name_buf[PP_TOKLEN_MAX+1];
nasm_zero(tmpl);
tmpl.nparam = 1;
tmpl.expand = stdmac_is;
name_buf[0] = '%';
name_buf[1] = 'i';
name_buf[2] = 's';
for (pt = PP_IF; pt < (PP_IFN+(PP_IFN-PP_IF)); pt++) {
if (!pp_directives[pt])
continue;
nasm_new(tmpl.params);
tmpl.params[0].flags = SPARM_GREEDY;
strcpy(name_buf+3, pp_directives[pt]+3);
tmpl.expandpvt.u = pt;
define_magic(name_buf, false, &tmpl);
}
}
/* Message macro functions */
static void pp_add_magic_msgfunc(void)
{
#if 0 /* Disabled, because they seem to be expanded inappropriately */
static const enum preproc_token msg_macros[] = {
PP_NOTE,
PP_WARNING,
PP_ERROR,
PP_FATAL
}, *mm;
SMacro tmpl;
nasm_zero(tmpl);
tmpl.nparam = 1;
tmpl.expand = stdmac_user_error;
array_for_each(mm, msg_macros) {
nasm_new(tmpl.params);
tmpl.params[0].flags = SPARM_GREEDY;
tmpl.expandpvt.u = *mm;
define_magic(pp_directives[*mm], false, &tmpl);
}
#endif
}
/* Ad hoc preprocessor function definitions */
static void pp_add_magic_miscfunc(void)
{
SMacro tmpl;
int i;
/* %hex() function */
nasm_zero(tmpl);
tmpl.nparam = 1;
tmpl.expand = stdmac_join;
nasm_newn(tmpl.params, tmpl.nparam);
tmpl.params[0].flags = SPARM_EVAL|SPARM_UNSIGNED|SPARM_VARADIC;
tmpl.params[0].radix = 'x';
define_magic("%hex", false, &tmpl);
/* %sel() function */
nasm_zero(tmpl);
tmpl.nparam = 2;
tmpl.expand = stdmac_sel;
nasm_newn(tmpl.params, tmpl.nparam);
tmpl.params[0].flags = SPARM_EVAL;
tmpl.params[1].flags = SPARM_VARADIC;
define_magic("%sel", false, &tmpl);
/* %cond() function */
nasm_zero(tmpl);
tmpl.nparam = 3;
tmpl.expand = stdmac_cond;
nasm_newn(tmpl.params, tmpl.nparam);
tmpl.params[0].flags = SPARM_EVAL;
tmpl.params[1].flags = 0;
tmpl.params[2].flags = SPARM_OPTIONAL;
define_magic("%cond", false, &tmpl);
/* %num() function */
nasm_zero(tmpl);
tmpl.nparam = 3;
tmpl.expand = stdmac_num;
tmpl.recursive = true;
nasm_newn(tmpl.params, tmpl.nparam);
tmpl.params[0].flags = SPARM_EVAL;
tmpl.params[1].flags = SPARM_EVAL|SPARM_OPTIONAL;
tmpl.params[1].def = make_tok_num(NULL, -1);
tmpl.params[2].flags = SPARM_EVAL|SPARM_OPTIONAL;
tmpl.params[2].def = make_tok_num(NULL, 10);
define_magic("%num", false, &tmpl);
/* %substr() function */
nasm_zero(tmpl);
tmpl.nparam = 3;
tmpl.expand = stdmac_substr;
tmpl.recursive = true;
nasm_newn(tmpl.params, tmpl.nparam);
tmpl.params[0].flags = SPARM_STR|SPARM_CONDQUOTE;
tmpl.params[1].flags = SPARM_EVAL;
tmpl.params[2].flags = SPARM_EVAL|SPARM_OPTIONAL;
tmpl.params[2].def = make_tok_num(NULL, -1);
define_magic("%substr", false, &tmpl);
/* %ord() function */
nasm_zero(tmpl);
tmpl.nparam = 3;
tmpl.expand = stdmac_ord;
tmpl.recursive = true;
nasm_newn(tmpl.params, tmpl.nparam);
tmpl.params[0].flags = SPARM_STR|SPARM_CONDQUOTE;
tmpl.params[1].flags = SPARM_EVAL|SPARM_OPTIONAL;
tmpl.params[1].def = make_tok_num(NULL, 1);
tmpl.params[2].flags = SPARM_EVAL|SPARM_OPTIONAL;
tmpl.params[2].def = make_tok_num(NULL, 1);
define_magic("%ord", false, &tmpl);
/* %b2hs() function */
nasm_zero(tmpl);
tmpl.nparam = 2;
tmpl.expand = stdmac_b2hs;
tmpl.recursive = true;
nasm_newn(tmpl.params, tmpl.nparam);
tmpl.params[0].flags = SPARM_STR|SPARM_CONDQUOTE;
tmpl.params[1].flags = SPARM_STR|SPARM_CONDQUOTE|SPARM_OPTIONAL;
tmpl.params[1].def = make_tok_qstr_len(NULL, "", 0);
define_magic("%b2hs", false, &tmpl);
/* %find[i]() functions */
for (i = 0; i < 2; i++) {
static const char * const names[] = { "%findi", "%find" };
nasm_zero(tmpl);
tmpl.nparam = 2;
tmpl.expand = stdmac_find;
tmpl.recursive = true;
nasm_newn(tmpl.params, tmpl.nparam);
tmpl.params[0].flags = SPARM_STR|SPARM_CONDQUOTE;
tmpl.params[1].flags = SPARM_VARADIC|SPARM_OPTIONAL;
tmpl.expandpvt.u = i;
define_magic(names[i], false, &tmpl);
}
}
static void pp_add_magic_stdmac(void)
{
pp_add_magic_simple();
pp_add_magic_isfunc();
pp_add_magic_msgfunc();
pp_add_magic_miscfunc();
}
static void pp_start_stdmac(void)
{
struct Include *inc;
stdmaclist = &stdmacset[0];
/*
* Set up the stdmac packages as a virtual include file,
* indicated by a null file pointer.
*/
nasm_new(inc);
inc->next = istk;
inc->nolist = inc->noline = !list_option('b');
inc->where = istk->where;
istk = inc;
if (!istk->nolist) {
lfmt->uplevel(LIST_INCLUDE, 0);
}
if (!istk->noline) {
src_set(0, NULL);
istk->where = src_where();
if (ppdbg & PDBG_INCLUDE)
dfmt->debug_include(true, istk->next->where, istk->where);
}
}
static void pp_reset_stdmac(enum preproc_mode mode)
{
int apass;
pp_start_stdmac();
pp_add_magic_stdmac();
if (tasm_compatible_mode)
pp_add_stdmac(&nasm_stdmac_tasm);
pp_add_stdmac(&nasm_stdmac_nasm);
pp_add_stdmac(&nasm_stdmac_version);
pp_add_stdmac(ofmt->stdmac);
do_predef = true;
/*
* Define the __?PASS?__ macro. This is defined here unlike all the
* other builtins, because it is special -- it varies between
* passes -- but there is really no particular reason to make it
* magic.
*
* 0 = dependencies only
* 1 = preparatory passes
* 2 = final pass
* 3 = preprocess only
*/
switch (mode) {
case PP_NORMAL:
apass = pass_final() ? 2 : 1;
break;
case PP_DEPS:
apass = 0;
break;
case PP_PREPROC:
apass = 3;
break;
default:
panic();
}
define_smacro("__?PASS?__", true, make_tok_num(NULL, apass), NULL);
}
void pp_reset(const char *file, enum preproc_mode mode,
struct strlist *dep_list)
{
cstk = NULL;
defining = NULL;
nested_mac_count = 0;
nested_rep_count = 0;
unique = 0;
deplist = dep_list;
pp_mode = mode;
/* Reset options to default */
nasm_zero(ppconf);
/* Disable all debugging info, except in the last pass */
ppdbg = 0;
if (!(ppopt & PP_TRIVIAL)) {
if (pass_final()) {
if (dfmt->debug_mmacros)
ppdbg |= PDBG_MMACROS;
if (dfmt->debug_smacros)
ppdbg |= PDBG_SMACROS;
if (dfmt->debug_include)
ppdbg |= PDBG_INCLUDE;
}
if (list_option('s'))
ppdbg |= PDBG_LIST_SMACROS;
}
memset(use_loaded, 0, use_package_count * sizeof(bool));
/* First set up the top level input file */
nasm_new(istk);
istk->fp = nasm_open_read(file, NF_TEXT);
if (!istk->fp) {
nasm_fatalf(ERR_NOFILE, "unable to open input file `%s'%s%s",
file, errno ? " " : "", errno ? strerror(errno) : "");
}
src_set(0, file);
istk->where = src_where();
istk->lineinc = 1;
if (ppdbg & PDBG_INCLUDE) {
/* Let the debug format know the main file */
dfmt->debug_include(true, src_nowhere(), istk->where);
}
strlist_add(deplist, file);
do_predef = false;
if (!(ppopt & PP_TRIVIAL))
pp_reset_stdmac(mode);
}
void pp_init(enum preproc_opt opt)
{
ppopt = opt;
nasm_newn(use_loaded, use_package_count);
}
/*
* Get a line of tokens. If we popped the macro expansion/include stack,
* we return a pointer to the dummy token tok_pop; at that point if
* istk is NULL then we have reached end of input;
*/
static Token tok_pop; /* Dummy token placeholder */
static Token *pp_tokline(void)
{
while (true) {
Line *l = istk->expansion;
Token *tline = NULL;
Token *dtline;
char *line = NULL;
bool suppressed = false;
check_mmacro_refcounts();
/*
* Fetch a tokenized line, either from the macro-expansion
* buffer or from the input file.
*/
while (l && l->finishes) {
MMacro *fm = l->finishes;
if (!fm->name && fm->in_progress > 1 && !l->suppressed) {
/*
* 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.
*/
fm->in_progress--;
list_for_each(l, fm->expansion) {
Line *ll;
nasm_new(ll);
ll->next = istk->expansion;
ll->first = dup_tlist(l->first, NULL);
ll->where = l->where;
istk->expansion = ll;
}
l = istk->expansion;
continue;
} else {
MMacro *m = istk->mstk.mstk;
nasm_assert(m == fm);
/*
* 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)
nasm_panic("defining with name in expansion");
else if (m->name)
nasm_fatal("`%%rep' without `%%endrep' within"
" expansion of macro `%s'", m->name);
}
/*
* FIXME: investigate the relationship at this point between
* istk->mstk.mstk and fm
*/
if (m->name) {
/*
* This was a real macro call, not a %rep, and
* therefore the parameter information needs to
* be freed and the iteration count/nesting
* depth adjusted.
*/
if (!--mmacro_deadman.levels) {
/*
* If all mmacro processing done,
* clear all counters and the deadman
* message trigger.
*/
nasm_zero(mmacro_deadman); /* Clear all counters */
}
#if 0
if (m->prev) {
pop_mmacro(m);
fm->in_progress --;
} else
#endif
{
clear_mmacro(m);
fm->in_progress = 0;
}
}
if (fm->nolist & NL_LINE) {
istk->noline--;
} else if (!istk->noline) {
MMacro *sm = (MMacro *)src_macro_current();
if (sm == fm) {
src_macro_pop();
put_mmacro(&sm);
}
src_update(l->where);
}
if (fm->nolist & NL_LIST) {
istk->nolist--;
} else if (!istk->nolist) {
lfmt->downlevel(LIST_MACRO);
if ((ppdbg & PDBG_MMACROS) && fm->name)
debug_macro_end(fm);
}
istk->where = l->where;
pop_mstk(&istk->mstk, m);
}
check_mmacro_refcounts();
istk->expansion = l->next;
free_line(l);
return &tok_pop;
}
if (istk->expansion) { /* from a macro expansion */
Line *l = istk->expansion;
check_mmacro_refcounts();
istk->expansion = l->next;
istk->where = l->where;
suppressed = l->suppressed;
if (!istk->noline)
src_update(istk->where);
tline = l->first;
l->first = NULL; /* Otherwise double free at free_line() */
if (!istk->nolist && !suppressed) {
char *listline;
listline = detoken(tline, false);
lfmt->line(LIST_MACRO, istk->where.lineno, listline);
nasm_free(listline);
}
free_line(l);
} else if ((line = read_line())) {
tline = tokenize(line);
nasm_free(line);
} else if (istk->expansion) {
/* read_line() might have modified istk->expansion */
continue;
} else {
/*
* The current file/input has ended; work down the istk
*/
Include *i = istk;
if (i->fp)
fclose(i->fp);
if (i->conds)
nasm_fatal("expected `%%endif' before end of file");
istk = i->next;
if (!i->nolist)
lfmt->downlevel(LIST_INCLUDE);
if (!i->noline) {
struct src_location whereto
= istk ? istk->where : src_nowhere();
if (ppdbg & PDBG_INCLUDE)
dfmt->debug_include(false, whereto, i->where);
if (istk)
src_update(istk->where);
}
put_mmacro(&i->mstk.mstk);
put_mmacro(&i->mstk.mmac);
nasm_free(i);
return &tok_pop;
}
/*
* If in a non-emitting branch, suppress this output line
*/
suppressed |= istk->conds && !emitting(istk->conds->state);
/*
* 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 && !suppressed)
tline = expand_mmac_params(tline);
/*
* Check the line to see if it's a preprocessor directive.
*/
if (do_directive(tline, &dtline, suppressed) == DIRECTIVE_FOUND) {
if (dtline)
return dtline;
} else if (defining) {
/*
* We're defining a multi-line macro. We emit nothing
* at all, and just
* shove the tokenized line on to the macro definition.
*/
MMacro *mmac = defining->dstk.mmac;
Line *l;
nasm_new(l);
l->next = defining->expansion;
l->first = tline;
l->finishes = NULL;
l->where = istk->where;
defining->expansion = l;
/*
* Remember if this mmacro expansion contains %00:
* if it does, we will have to handle leading labels
* specially.
*/
if (mmac) {
const Token *t;
list_for_each(t, tline) {
if (t->type == TOKEN_MMACRO_PARAM &&
!memcmp(t->text.a, "%00", 4))
mmac->capture_label = true;
}
}
} else if (suppressed) {
/*
* We're in a non-emitting branch of a condition block,
* or a %rep block or macro that has been terminated.
* 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.
*/
delete_tlist(tline);
} else {
tline = expand_smacro(tline);
if (!expand_mmacro(tline))
return tline;
}
}
}
char *pp_getline(void)
{
char *line = NULL;
Token *tline;
while (true) {
tline = pp_tokline();
if (tline == &tok_pop) {
/*
* We popped the macro/include stack. If istk is empty,
* we are at end of input, otherwise just loop back.
*/
if (!istk)
break;
} else {
/*
* De-tokenize the line and emit it.
*/
line = detoken(tline, true);
delete_tlist(tline);
break;
}
}
if (list_option('e') && istk && !istk->nolist && line && line[0]) {
char *buf = nasm_strcat(" ;;; ", line);
lfmt->line(LIST_MACRO, -1, buf);
nasm_free(buf);
}
return line;
}
void pp_cleanup_pass(void)
{
if (defining) {
if (defining->name) {
nasm_nonfatal("end of file while still defining macro `%s'",
defining->name);
} else {
nasm_nonfatal("end of file while still in %%rep");
}
free_mmacro(defining);
defining = NULL;
}
while (cstk)
ctx_pop();
free_macros();
while (istk) {
Include *i = istk;
istk = istk->next;
fclose(i->fp);
if (!istk && (ppdbg & PDBG_INCLUDE)) {
/* Signal closing the top-level input file */
dfmt->debug_include(false, src_nowhere(), i->where);
}
nasm_free(i);
}
while (cstk)
ctx_pop();
src_set_fname(NULL);
if (ppdbg & PDBG_MMACROS)
debug_macro_output();
}
void pp_cleanup_session(void)
{
nasm_free(use_loaded);
free_llist(predef);
predef = NULL;
free_Blocks();
ipath_list = NULL;
}
void pp_include_path(struct strlist *list)
{
ipath_list = list;
}
void pp_pre_include(char *fname)
{
Token *inc, *space, *name;
Line *l;
name = new_Token(NULL, TOKEN_INTERNAL_STR, fname, 0);
space = new_White(name);
inc = new_Token(space, TOKEN_PREPROC_ID, "%include", 0);
l = nasm_malloc(sizeof(Line));
l->next = predef;
l->first = inc;
l->finishes = NULL;
predef = l;
}
void pp_pre_define(char *definition)
{
Token *def, *space;
Line *l;
char *equals;
equals = strchr(definition, '=');
space = new_White(NULL);
def = new_Token(space, TOKEN_PREPROC_ID, "%define", 0);
if (equals)
*equals = ' ';
space->next = tokenize(definition);
if (equals)
*equals = '=';
nasm_new(l);
l->next = predef;
l->first = def;
l->finishes = NULL;
predef = l;
}
void pp_pre_undefine(char *definition)
{
Token *def, *space;
Line *l;
space = new_White(NULL);
def = new_Token(space, TOKEN_PREPROC_ID, "%undef", 0);
space->next = tokenize(definition);
nasm_new(l);
l->next = predef;
l->first = def;
l->finishes = NULL;
predef = l;
}
/* Insert an early preprocessor command that doesn't need special handling */
void pp_pre_command(const char *what, char *string)
{
Token *def;
Line *l;
def = tokenize(string);
if (what) {
Token *wt = tokenize(what);
Token **tailp = tlist_endptr(&wt);
*tailp = new_White(def);
def = wt;
}
nasm_new(l);
l->next = predef;
l->first = def;
l->finishes = NULL;
predef = l;
}
static void pp_add_stdmac(macros_t *macros)
{
macros_t **mp;
/* Find the end of the list and avoid duplicates */
for (mp = stdmacset; *mp; mp++) {
if (*mp == macros)
return; /* Nothing to do */
}
nasm_assert(mp < &stdmacset[ARRAY_SIZE(stdmacset)-1]);
*mp = macros;
}
/* Create a numeric token, with possible - token in front */
static Token *make_tok_num(Token *next, int64_t val)
{
char numbuf[32];
int len;
uint64_t uval;
bool minus = val < 0;
uval = minus ? -val : val;
len = snprintf(numbuf, sizeof numbuf, "%"PRIu64, uval);
next = new_Token(next, TOKEN_NUM, numbuf, len);
if (minus)
next = make_tok_char(next, '-');
return next;
}
/*
* Create a numeric token with specified radix and signedness;
* prefix the number with 0<radix> if a radix letter is specified,
* otherwise generate a decimal constant without prefix.
*/
static Token *
make_tok_num_radix(Token *next, int64_t val, char radix, bool uns)
{
char numbuf[2+64+1]; /* Maximum possible: 0b + binary + null */
char *p;
uint64_t uval;
bool minus = val < 0 && !uns;
unsigned int base;
bool upper;
uval = minus ? -val : val;
p = numbuf;
base = 10;
upper = false;
if (radix) {
*p++ = '0';
*p++ = radix;
base = radix_letter(radix);
upper = !(radix & 0x20);
}
p += numstr(p, 64, uval, -1, base, upper);
next = new_Token(next, TOKEN_NUM, numbuf, p - numbuf);
if (minus)
next = make_tok_char(next, '-');
return next;
}
/*
* Do the inverse of make_tok_num(). This only needs to be able
* to parse the output of make_tok_num() or make_tok_hex().
*/
static int64_t get_tok_num(const Token *t, bool *err)
{
bool minus = false;
int64_t v;
if (tok_is(t, '-')) {
minus = true;
t = t->next;
}
if (!tok_is(t, TOKEN_NUM)) {
if (err)
*err = true;
return 0;
}
v = readnum(tok_text(t), err);
return minus ? -v : v;
}
/* Create a quoted string token */
static Token *make_tok_qstr_len(Token *next, const char *str, size_t len)
{
char *p = nasm_quote(str, &len);
return new_Token_free(next, TOKEN_STR, p, len);
}
static Token *make_tok_qstr(Token *next, const char *str)
{
return make_tok_qstr_len(next, str, strlen(str));
}
/* Create a single-character operator token */
static Token *make_tok_char(Token *next, char op)
{
Token *t = new_Token(next, op, NULL, 1);
t->text.a[0] = op;
return t;
}
/*
* Descent the macro hierarchy and display the expansion after
* encountering an error message.
*/
void pp_error_list_macros(errflags severity)
{
const MMacro *m;
severity |= ERR_PP_LISTMACRO | ERR_NO_SEVERITY | ERR_HERE;
while ((m = src_error_down())) {
if ((m->nolist & NL_LIST) || !m->where.filename)
break;
nasm_error(severity, "... from macro `%s' defined", m->name);
}
src_error_reset();
}
#if DEBUG_MMACRO_REFCOUNTS
static inline void mmac_dbgref(MMacro *m)
{
if (m)
m->refdbg.cnt++;
}
static void mmac_hashref(struct hash_table *mmt)
{
struct hash_iterator it;
const struct hash_node *np;
hash_for_each(mmt, it, np)
mmac_dbgref(np->data);
}
/* Scan everything and compute correct refcnts, then warn on discrepancies */
static void check_mmacro_refcounts(void)
{
MMacro *m;
Include *i;
Line *l;
bool err;
for (m = refdbg_list; m; m = m->refdbg.next)
m->refdbg.cnt = 0;
for (m = refdbg_list; m; m = m->refdbg.next) {
mmac_dbgref(m->next);
mmac_dbgref(m->mstk.mstk);
mmac_dbgref(m->mstk.mmac);
mmac_dbgref(m->dstk.mstk);
mmac_dbgref(m->dstk.mmac);
}
mmac_hashref(&mmacros);
mmac_dbgref(defining);
for (i = istk; i; i = i->next) {
mmac_dbgref(i->mstk.mstk);
mmac_dbgref(i->mstk.mmac);
for (l = i->expansion; l; l = l->next)
mmac_dbgref(l->finishes);
}
mmac_dbgref((MMacro *)src_macro_current());
err = false;
for (m = refdbg_list; m; m = m->refdbg.next) {
if (m->refcnt != m->refdbg.cnt) {
nasm_info("macro %s @ %p refcnt %zu should be %zu\n",
m->name ? m->name : "<rep>", (void *)m,
m->refcnt, m->refdbg.cnt);
err = true;
}
}
if (err)
panic();
}
#endif