fix unitialized variable in eval_strfunc
[nasm.git] / preproc.c
blob045526821f041d4af738b0f5b8e03d9f5356ea22
1 /* preproc.c macro preprocessor for the Netwide Assembler
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the license given in the file "LICENSE"
6 * distributed in the NASM archive.
8 * initial version 18/iii/97 by Simon Tatham
9 */
11 /* Typical flow of text through preproc
13 * pp_getline gets tokenized lines, either
15 * from a macro expansion
17 * or
18 * {
19 * read_line gets raw text from stdmacpos, or predef, or current input file
20 * tokenize converts to tokens
21 * }
23 * expand_mmac_params is used to expand %1 etc., unless a macro is being
24 * defined or a false conditional is being processed
25 * (%0, %1, %+1, %-1, %%foo
27 * do_directive checks for directives
29 * expand_smacro is used to expand single line macros
31 * expand_mmacro is used to expand multi-line macros
33 * detoken is used to convert the line back to text
36 #include "compiler.h"
38 #include <stdio.h>
39 #include <stdarg.h>
40 #include <stdlib.h>
41 #include <stddef.h>
42 #include <string.h>
43 #include <ctype.h>
44 #include <limits.h>
45 #include <inttypes.h>
47 #include "nasm.h"
48 #include "nasmlib.h"
49 #include "preproc.h"
50 #include "hashtbl.h"
51 #include "quote.h"
52 #include "stdscan.h"
53 #include "tokens.h"
54 #include "tables.h"
56 typedef struct SMacro SMacro;
57 typedef struct MMacro MMacro;
58 typedef struct Context Context;
59 typedef struct Token Token;
60 typedef struct Blocks Blocks;
61 typedef struct Line Line;
62 typedef struct Include Include;
63 typedef struct Cond Cond;
64 typedef struct IncPath IncPath;
67 * Note on the storage of both SMacro and MMacros: the hash table
68 * indexes them case-insensitively, and we then have to go through a
69 * linked list of potential case aliases (and, for MMacros, parameter
70 * ranges); this is to preserve the matching semantics of the earlier
71 * code. If the number of case aliases for a specific macro is a
72 * performance issue, you may want to reconsider your coding style.
76 * Store the definition of a single-line macro.
78 struct SMacro {
79 SMacro *next;
80 char *name;
81 bool casesense;
82 bool in_progress;
83 unsigned int nparam;
84 Token *expansion;
88 * Store the definition of a multi-line macro. This is also used to
89 * store the interiors of `%rep...%endrep' blocks, which are
90 * effectively self-re-invoking multi-line macros which simply
91 * don't have a name or bother to appear in the hash tables. %rep
92 * blocks are signified by having a NULL `name' field.
94 * In a MMacro describing a `%rep' block, the `in_progress' field
95 * isn't merely boolean, but gives the number of repeats left to
96 * run.
98 * The `next' field is used for storing MMacros in hash tables; the
99 * `next_active' field is for stacking them on istk entries.
101 * When a MMacro is being expanded, `params', `iline', `nparam',
102 * `paramlen', `rotate' and `unique' are local to the invocation.
104 struct MMacro {
105 MMacro *next;
106 char *name;
107 int nparam_min, nparam_max;
108 bool casesense;
109 bool plus; /* is the last parameter greedy? */
110 bool nolist; /* is this macro listing-inhibited? */
111 int64_t in_progress;
112 Token *dlist; /* All defaults as one list */
113 Token **defaults; /* Parameter default pointers */
114 int ndefs; /* number of default parameters */
115 Line *expansion;
117 MMacro *next_active;
118 MMacro *rep_nest; /* used for nesting %rep */
119 Token **params; /* actual parameters */
120 Token *iline; /* invocation line */
121 unsigned int nparam, rotate;
122 int *paramlen;
123 uint64_t unique;
124 int lineno; /* Current line number on expansion */
128 * The context stack is composed of a linked list of these.
130 struct Context {
131 Context *next;
132 char *name;
133 struct hash_table localmac;
134 uint32_t number;
138 * This is the internal form which we break input lines up into.
139 * Typically stored in linked lists.
141 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
142 * necessarily used as-is, but is intended to denote the number of
143 * the substituted parameter. So in the definition
145 * %define a(x,y) ( (x) & ~(y) )
147 * the token representing `x' will have its type changed to
148 * TOK_SMAC_PARAM, but the one representing `y' will be
149 * TOK_SMAC_PARAM+1.
151 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
152 * which doesn't need quotes around it. Used in the pre-include
153 * mechanism as an alternative to trying to find a sensible type of
154 * quote to use on the filename we were passed.
156 enum pp_token_type {
157 TOK_NONE = 0, TOK_WHITESPACE, TOK_COMMENT, TOK_ID,
158 TOK_PREPROC_ID, TOK_STRING,
159 TOK_NUMBER, TOK_FLOAT, TOK_SMAC_END, TOK_OTHER,
160 TOK_INTERNAL_STRING,
161 TOK_PREPROC_Q, TOK_PREPROC_QQ,
162 TOK_SMAC_PARAM, /* MUST BE LAST IN THE LIST!!! */
163 TOK_MAX = INT_MAX /* Keep compiler from reducing the range */
166 struct Token {
167 Token *next;
168 char *text;
169 union {
170 SMacro *mac; /* associated macro for TOK_SMAC_END */
171 size_t len; /* scratch length field */
172 } a; /* Auxiliary data */
173 enum pp_token_type type;
177 * Multi-line macro definitions are stored as a linked list of
178 * these, which is essentially a container to allow several linked
179 * lists of Tokens.
181 * Note that in this module, linked lists are treated as stacks
182 * wherever possible. For this reason, Lines are _pushed_ on to the
183 * `expansion' field in MMacro structures, so that the linked list,
184 * if walked, would give the macro lines in reverse order; this
185 * means that we can walk the list when expanding a macro, and thus
186 * push the lines on to the `expansion' field in _istk_ in reverse
187 * order (so that when popped back off they are in the right
188 * order). It may seem cockeyed, and it relies on my design having
189 * an even number of steps in, but it works...
191 * Some of these structures, rather than being actual lines, are
192 * markers delimiting the end of the expansion of a given macro.
193 * This is for use in the cycle-tracking and %rep-handling code.
194 * Such structures have `finishes' non-NULL, and `first' NULL. All
195 * others have `finishes' NULL, but `first' may still be NULL if
196 * the line is blank.
198 struct Line {
199 Line *next;
200 MMacro *finishes;
201 Token *first;
205 * To handle an arbitrary level of file inclusion, we maintain a
206 * stack (ie linked list) of these things.
208 struct Include {
209 Include *next;
210 FILE *fp;
211 Cond *conds;
212 Line *expansion;
213 char *fname;
214 int lineno, lineinc;
215 MMacro *mstk; /* stack of active macros/reps */
219 * Include search path. This is simply a list of strings which get
220 * prepended, in turn, to the name of an include file, in an
221 * attempt to find the file if it's not in the current directory.
223 struct IncPath {
224 IncPath *next;
225 char *path;
229 * Conditional assembly: we maintain a separate stack of these for
230 * each level of file inclusion. (The only reason we keep the
231 * stacks separate is to ensure that a stray `%endif' in a file
232 * included from within the true branch of a `%if' won't terminate
233 * it and cause confusion: instead, rightly, it'll cause an error.)
235 struct Cond {
236 Cond *next;
237 int state;
239 enum {
241 * These states are for use just after %if or %elif: IF_TRUE
242 * means the condition has evaluated to truth so we are
243 * currently emitting, whereas IF_FALSE means we are not
244 * currently emitting but will start doing so if a %else comes
245 * up. In these states, all directives are admissible: %elif,
246 * %else and %endif. (And of course %if.)
248 COND_IF_TRUE, COND_IF_FALSE,
250 * These states come up after a %else: ELSE_TRUE means we're
251 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
252 * any %elif or %else will cause an error.
254 COND_ELSE_TRUE, COND_ELSE_FALSE,
256 * This state means that we're not emitting now, and also that
257 * nothing until %endif will be emitted at all. It's for use in
258 * two circumstances: (i) when we've had our moment of emission
259 * and have now started seeing %elifs, and (ii) when the
260 * condition construct in question is contained within a
261 * non-emitting branch of a larger condition construct.
263 COND_NEVER
265 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
268 * These defines are used as the possible return values for do_directive
270 #define NO_DIRECTIVE_FOUND 0
271 #define DIRECTIVE_FOUND 1
274 * Condition codes. Note that we use c_ prefix not C_ because C_ is
275 * used in nasm.h for the "real" condition codes. At _this_ level,
276 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
277 * ones, so we need a different enum...
279 static const char * const conditions[] = {
280 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
281 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
282 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
284 enum pp_conds {
285 c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE,
286 c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO,
287 c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_RCXZ, c_S, c_Z,
288 c_none = -1
290 static const enum pp_conds inverse_ccs[] = {
291 c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE,
292 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,
293 c_Z, c_NO, c_NP, c_PO, c_PE, -1, c_NS, c_NZ
297 * Directive names.
299 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
300 static int is_condition(enum preproc_token arg)
302 return PP_IS_COND(arg) || (arg == PP_ELSE) || (arg == PP_ENDIF);
305 /* For TASM compatibility we need to be able to recognise TASM compatible
306 * conditional compilation directives. Using the NASM pre-processor does
307 * not work, so we look for them specifically from the following list and
308 * then jam in the equivalent NASM directive into the input stream.
311 enum {
312 TM_ARG, TM_ELIF, TM_ELSE, TM_ENDIF, TM_IF, TM_IFDEF, TM_IFDIFI,
313 TM_IFNDEF, TM_INCLUDE, TM_LOCAL
316 static const char * const tasm_directives[] = {
317 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
318 "ifndef", "include", "local"
321 static int StackSize = 4;
322 static char *StackPointer = "ebp";
323 static int ArgOffset = 8;
324 static int LocalOffset = 0;
326 static Context *cstk;
327 static Include *istk;
328 static IncPath *ipath = NULL;
330 static efunc _error; /* Pointer to client-provided error reporting function */
331 static evalfunc evaluate;
333 static int pass; /* HACK: pass 0 = generate dependencies only */
334 static StrList **dephead, **deptail; /* Dependency list */
336 static uint64_t unique; /* unique identifier numbers */
338 static Line *predef = NULL;
339 static bool do_predef;
341 static ListGen *list;
344 * The current set of multi-line macros we have defined.
346 static struct hash_table mmacros;
349 * The current set of single-line macros we have defined.
351 static struct hash_table smacros;
354 * The multi-line macro we are currently defining, or the %rep
355 * block we are currently reading, if any.
357 static MMacro *defining;
359 static uint64_t nested_mac_count;
360 static uint64_t nested_rep_count;
363 * The number of macro parameters to allocate space for at a time.
365 #define PARAM_DELTA 16
368 * The standard macro set: defined in macros.c in the array nasm_stdmac.
369 * This gives our position in the macro set, when we're processing it.
371 static const macros_t *stdmacpos;
374 * The extra standard macros that come from the object format, if
375 * any.
377 static const macros_t *extrastdmac = NULL;
378 static bool any_extrastdmac;
381 * Tokens are allocated in blocks to improve speed
383 #define TOKEN_BLOCKSIZE 4096
384 static Token *freeTokens = NULL;
385 struct Blocks {
386 Blocks *next;
387 void *chunk;
390 static Blocks blocks = { NULL, NULL };
393 * Forward declarations.
395 static Token *expand_mmac_params(Token * tline);
396 static Token *expand_smacro(Token * tline);
397 static Token *expand_id(Token * tline);
398 static Context *get_ctx(const char *name, bool all_contexts);
399 static void make_tok_num(Token * tok, int64_t val);
400 static void error(int severity, const char *fmt, ...);
401 static void *new_Block(size_t size);
402 static void delete_Blocks(void);
403 static Token *new_Token(Token * next, enum pp_token_type type,
404 const char *text, int txtlen);
405 static Token *delete_Token(Token * t);
408 * Macros for safe checking of token pointers, avoid *(NULL)
410 #define tok_type_(x,t) ((x) && (x)->type == (t))
411 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
412 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
413 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
415 /* Handle TASM specific directives, which do not contain a % in
416 * front of them. We do it here because I could not find any other
417 * place to do it for the moment, and it is a hack (ideally it would
418 * be nice to be able to use the NASM pre-processor to do it).
420 static char *check_tasm_directive(char *line)
422 int32_t i, j, k, m, len;
423 char *p = line, *oldline, oldchar;
425 /* Skip whitespace */
426 while (nasm_isspace(*p) && *p != 0)
427 p++;
429 /* Binary search for the directive name */
430 i = -1;
431 j = elements(tasm_directives);
432 len = 0;
433 while (!nasm_isspace(p[len]) && p[len] != 0)
434 len++;
435 if (len) {
436 oldchar = p[len];
437 p[len] = 0;
438 while (j - i > 1) {
439 k = (j + i) / 2;
440 m = nasm_stricmp(p, tasm_directives[k]);
441 if (m == 0) {
442 /* We have found a directive, so jam a % in front of it
443 * so that NASM will then recognise it as one if it's own.
445 p[len] = oldchar;
446 len = strlen(p);
447 oldline = line;
448 line = nasm_malloc(len + 2);
449 line[0] = '%';
450 if (k == TM_IFDIFI) {
451 /* NASM does not recognise IFDIFI, so we convert it to
452 * %ifdef BOGUS. This is not used in NASM comaptible
453 * code, but does need to parse for the TASM macro
454 * package.
456 strcpy(line + 1, "ifdef BOGUS");
457 } else {
458 memcpy(line + 1, p, len + 1);
460 nasm_free(oldline);
461 return line;
462 } else if (m < 0) {
463 j = k;
464 } else
465 i = k;
467 p[len] = oldchar;
469 return line;
473 * The pre-preprocessing stage... This function translates line
474 * number indications as they emerge from GNU cpp (`# lineno "file"
475 * flags') into NASM preprocessor line number indications (`%line
476 * lineno file').
478 static char *prepreproc(char *line)
480 int lineno, fnlen;
481 char *fname, *oldline;
483 if (line[0] == '#' && line[1] == ' ') {
484 oldline = line;
485 fname = oldline + 2;
486 lineno = atoi(fname);
487 fname += strspn(fname, "0123456789 ");
488 if (*fname == '"')
489 fname++;
490 fnlen = strcspn(fname, "\"");
491 line = nasm_malloc(20 + fnlen);
492 snprintf(line, 20 + fnlen, "%%line %d %.*s", lineno, fnlen, fname);
493 nasm_free(oldline);
495 if (tasm_compatible_mode)
496 return check_tasm_directive(line);
497 return line;
501 * Free a linked list of tokens.
503 static void free_tlist(Token * list)
505 while (list) {
506 list = delete_Token(list);
511 * Free a linked list of lines.
513 static void free_llist(Line * list)
515 Line *l;
516 while (list) {
517 l = list;
518 list = list->next;
519 free_tlist(l->first);
520 nasm_free(l);
525 * Free an MMacro
527 static void free_mmacro(MMacro * m)
529 nasm_free(m->name);
530 free_tlist(m->dlist);
531 nasm_free(m->defaults);
532 free_llist(m->expansion);
533 nasm_free(m);
537 * Free all currently defined macros, and free the hash tables
539 static void free_smacro_table(struct hash_table *smt)
541 SMacro *s;
542 const char *key;
543 struct hash_tbl_node *it = NULL;
545 while ((s = hash_iterate(smt, &it, &key)) != NULL) {
546 nasm_free((void *)key);
547 while (s) {
548 SMacro *ns = s->next;
549 nasm_free(s->name);
550 free_tlist(s->expansion);
551 nasm_free(s);
552 s = ns;
555 hash_free(smt);
558 static void free_mmacro_table(struct hash_table *mmt)
560 MMacro *m;
561 const char *key;
562 struct hash_tbl_node *it = NULL;
564 it = NULL;
565 while ((m = hash_iterate(mmt, &it, &key)) != NULL) {
566 nasm_free((void *)key);
567 while (m) {
568 MMacro *nm = m->next;
569 free_mmacro(m);
570 m = nm;
573 hash_free(mmt);
576 static void free_macros(void)
578 free_smacro_table(&smacros);
579 free_mmacro_table(&mmacros);
583 * Initialize the hash tables
585 static void init_macros(void)
587 hash_init(&smacros, HASH_LARGE);
588 hash_init(&mmacros, HASH_LARGE);
592 * Pop the context stack.
594 static void ctx_pop(void)
596 Context *c = cstk;
598 cstk = cstk->next;
599 free_smacro_table(&c->localmac);
600 nasm_free(c->name);
601 nasm_free(c);
605 * Search for a key in the hash index; adding it if necessary
606 * (in which case we initialize the data pointer to NULL.)
608 static void **
609 hash_findi_add(struct hash_table *hash, const char *str)
611 struct hash_insert hi;
612 void **r;
613 char *strx;
615 r = hash_findi(hash, str, &hi);
616 if (r)
617 return r;
619 strx = nasm_strdup(str); /* Use a more efficient allocator here? */
620 return hash_add(&hi, strx, NULL);
624 * Like hash_findi, but returns the data element rather than a pointer
625 * to it. Used only when not adding a new element, hence no third
626 * argument.
628 static void *
629 hash_findix(struct hash_table *hash, const char *str)
631 void **p;
633 p = hash_findi(hash, str, NULL);
634 return p ? *p : NULL;
637 #define BUF_DELTA 512
639 * Read a line from the top file in istk, handling multiple CR/LFs
640 * at the end of the line read, and handling spurious ^Zs. Will
641 * return lines from the standard macro set if this has not already
642 * been done.
644 static char *read_line(void)
646 char *buffer, *p, *q;
647 int bufsize, continued_count;
649 if (stdmacpos) {
650 unsigned char c;
651 const unsigned char *p = stdmacpos;
652 char *ret, *q;
653 size_t len = 0;
654 while ((c = *p++)) {
655 if (c >= 0x80)
656 len += pp_directives_len[c-0x80]+1;
657 else
658 len++;
660 ret = nasm_malloc(len+1);
661 q = ret;
662 while ((c = *stdmacpos++)) {
663 if (c >= 0x80) {
664 memcpy(q, pp_directives[c-0x80], pp_directives_len[c-0x80]);
665 q += pp_directives_len[c-0x80];
666 *q++ = ' ';
667 } else {
668 *q++ = c;
671 stdmacpos = p;
672 *q = '\0';
674 if (!*stdmacpos) {
675 /* This was the last of the standard macro chain... */
676 stdmacpos = NULL;
677 if (any_extrastdmac) {
678 stdmacpos = extrastdmac;
679 any_extrastdmac = false;
680 } else if (do_predef) {
681 Line *pd, *l;
682 Token *head, **tail, *t;
685 * Nasty hack: here we push the contents of
686 * `predef' on to the top-level expansion stack,
687 * since this is the most convenient way to
688 * implement the pre-include and pre-define
689 * features.
691 for (pd = predef; pd; pd = pd->next) {
692 head = NULL;
693 tail = &head;
694 for (t = pd->first; t; t = t->next) {
695 *tail = new_Token(NULL, t->type, t->text, 0);
696 tail = &(*tail)->next;
698 l = nasm_malloc(sizeof(Line));
699 l->next = istk->expansion;
700 l->first = head;
701 l->finishes = NULL;
702 istk->expansion = l;
704 do_predef = false;
707 return ret;
710 bufsize = BUF_DELTA;
711 buffer = nasm_malloc(BUF_DELTA);
712 p = buffer;
713 continued_count = 0;
714 while (1) {
715 q = fgets(p, bufsize - (p - buffer), istk->fp);
716 if (!q)
717 break;
718 p += strlen(p);
719 if (p > buffer && p[-1] == '\n') {
720 /* Convert backslash-CRLF line continuation sequences into
721 nothing at all (for DOS and Windows) */
722 if (((p - 2) > buffer) && (p[-3] == '\\') && (p[-2] == '\r')) {
723 p -= 3;
724 *p = 0;
725 continued_count++;
727 /* Also convert backslash-LF line continuation sequences into
728 nothing at all (for Unix) */
729 else if (((p - 1) > buffer) && (p[-2] == '\\')) {
730 p -= 2;
731 *p = 0;
732 continued_count++;
733 } else {
734 break;
737 if (p - buffer > bufsize - 10) {
738 int32_t offset = p - buffer;
739 bufsize += BUF_DELTA;
740 buffer = nasm_realloc(buffer, bufsize);
741 p = buffer + offset; /* prevent stale-pointer problems */
745 if (!q && p == buffer) {
746 nasm_free(buffer);
747 return NULL;
750 src_set_linnum(src_get_linnum() + istk->lineinc +
751 (continued_count * istk->lineinc));
754 * Play safe: remove CRs as well as LFs, if any of either are
755 * present at the end of the line.
757 while (--p >= buffer && (*p == '\n' || *p == '\r'))
758 *p = '\0';
761 * Handle spurious ^Z, which may be inserted into source files
762 * by some file transfer utilities.
764 buffer[strcspn(buffer, "\032")] = '\0';
766 list->line(LIST_READ, buffer);
768 return buffer;
772 * Tokenize a line of text. This is a very simple process since we
773 * don't need to parse the value out of e.g. numeric tokens: we
774 * simply split one string into many.
776 static Token *tokenize(char *line)
778 char *p = line;
779 enum pp_token_type type;
780 Token *list = NULL;
781 Token *t, **tail = &list;
783 while (*line) {
784 p = line;
785 if (*p == '%') {
786 p++;
787 if (nasm_isdigit(*p) ||
788 ((*p == '-' || *p == '+') && nasm_isdigit(p[1])) ||
789 ((*p == '+') && (nasm_isspace(p[1]) || !p[1]))) {
790 do {
791 p++;
793 while (nasm_isdigit(*p));
794 type = TOK_PREPROC_ID;
795 } else if (*p == '{') {
796 p++;
797 while (*p && *p != '}') {
798 p[-1] = *p;
799 p++;
801 p[-1] = '\0';
802 if (*p)
803 p++;
804 type = TOK_PREPROC_ID;
805 } else if (*p == '?') {
806 type = TOK_PREPROC_Q; /* %? */
807 p++;
808 if (*p == '?') {
809 type = TOK_PREPROC_QQ; /* %?? */
810 p++;
812 } else if (isidchar(*p) ||
813 ((*p == '!' || *p == '%' || *p == '$') &&
814 isidchar(p[1]))) {
815 do {
816 p++;
818 while (isidchar(*p));
819 type = TOK_PREPROC_ID;
820 } else {
821 type = TOK_OTHER;
822 if (*p == '%')
823 p++;
825 } else if (isidstart(*p) || (*p == '$' && isidstart(p[1]))) {
826 type = TOK_ID;
827 p++;
828 while (*p && isidchar(*p))
829 p++;
830 } else if (*p == '\'' || *p == '"' || *p == '`') {
832 * A string token.
834 type = TOK_STRING;
835 p = nasm_skip_string(p);
837 if (*p) {
838 p++;
839 } else {
840 error(ERR_WARNING, "unterminated string");
841 /* Handling unterminated strings by UNV */
842 /* type = -1; */
844 } else if (isnumstart(*p)) {
845 bool is_hex = false;
846 bool is_float = false;
847 bool has_e = false;
848 char c, *r;
851 * A numeric token.
854 if (*p == '$') {
855 p++;
856 is_hex = true;
859 for (;;) {
860 c = *p++;
862 if (!is_hex && (c == 'e' || c == 'E')) {
863 has_e = true;
864 if (*p == '+' || *p == '-') {
865 /* e can only be followed by +/- if it is either a
866 prefixed hex number or a floating-point number */
867 p++;
868 is_float = true;
870 } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') {
871 is_hex = true;
872 } else if (c == 'P' || c == 'p') {
873 is_float = true;
874 if (*p == '+' || *p == '-')
875 p++;
876 } else if (isnumchar(c) || c == '_')
877 ; /* just advance */
878 else if (c == '.') {
879 /* we need to deal with consequences of the legacy
880 parser, like "1.nolist" being two tokens
881 (TOK_NUMBER, TOK_ID) here; at least give it
882 a shot for now. In the future, we probably need
883 a flex-based scanner with proper pattern matching
884 to do it as well as it can be done. Nothing in
885 the world is going to help the person who wants
886 0x123.p16 interpreted as two tokens, though. */
887 r = p;
888 while (*r == '_')
889 r++;
891 if (nasm_isdigit(*r) || (is_hex && nasm_isxdigit(*r)) ||
892 (!is_hex && (*r == 'e' || *r == 'E')) ||
893 (*r == 'p' || *r == 'P')) {
894 p = r;
895 is_float = true;
896 } else
897 break; /* Terminate the token */
898 } else
899 break;
901 p--; /* Point to first character beyond number */
903 if (has_e && !is_hex) {
904 /* 1e13 is floating-point, but 1e13h is not */
905 is_float = true;
908 type = is_float ? TOK_FLOAT : TOK_NUMBER;
909 } else if (nasm_isspace(*p)) {
910 type = TOK_WHITESPACE;
911 p++;
912 while (*p && nasm_isspace(*p))
913 p++;
915 * Whitespace just before end-of-line is discarded by
916 * pretending it's a comment; whitespace just before a
917 * comment gets lumped into the comment.
919 if (!*p || *p == ';') {
920 type = TOK_COMMENT;
921 while (*p)
922 p++;
924 } else if (*p == ';') {
925 type = TOK_COMMENT;
926 while (*p)
927 p++;
928 } else {
930 * Anything else is an operator of some kind. We check
931 * for all the double-character operators (>>, <<, //,
932 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
933 * else is a single-character operator.
935 type = TOK_OTHER;
936 if ((p[0] == '>' && p[1] == '>') ||
937 (p[0] == '<' && p[1] == '<') ||
938 (p[0] == '/' && p[1] == '/') ||
939 (p[0] == '<' && p[1] == '=') ||
940 (p[0] == '>' && p[1] == '=') ||
941 (p[0] == '=' && p[1] == '=') ||
942 (p[0] == '!' && p[1] == '=') ||
943 (p[0] == '<' && p[1] == '>') ||
944 (p[0] == '&' && p[1] == '&') ||
945 (p[0] == '|' && p[1] == '|') ||
946 (p[0] == '^' && p[1] == '^')) {
947 p++;
949 p++;
952 /* Handling unterminated string by UNV */
953 /*if (type == -1)
955 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
956 t->text[p-line] = *line;
957 tail = &t->next;
959 else */
960 if (type != TOK_COMMENT) {
961 *tail = t = new_Token(NULL, type, line, p - line);
962 tail = &t->next;
964 line = p;
966 return list;
970 * this function allocates a new managed block of memory and
971 * returns a pointer to the block. The managed blocks are
972 * deleted only all at once by the delete_Blocks function.
974 static void *new_Block(size_t size)
976 Blocks *b = &blocks;
978 /* first, get to the end of the linked list */
979 while (b->next)
980 b = b->next;
981 /* now allocate the requested chunk */
982 b->chunk = nasm_malloc(size);
984 /* now allocate a new block for the next request */
985 b->next = nasm_malloc(sizeof(Blocks));
986 /* and initialize the contents of the new block */
987 b->next->next = NULL;
988 b->next->chunk = NULL;
989 return b->chunk;
993 * this function deletes all managed blocks of memory
995 static void delete_Blocks(void)
997 Blocks *a, *b = &blocks;
1000 * keep in mind that the first block, pointed to by blocks
1001 * is a static and not dynamically allocated, so we don't
1002 * free it.
1004 while (b) {
1005 if (b->chunk)
1006 nasm_free(b->chunk);
1007 a = b;
1008 b = b->next;
1009 if (a != &blocks)
1010 nasm_free(a);
1015 * this function creates a new Token and passes a pointer to it
1016 * back to the caller. It sets the type and text elements, and
1017 * also the a.mac and next elements to NULL.
1019 static Token *new_Token(Token * next, enum pp_token_type type,
1020 const char *text, int txtlen)
1022 Token *t;
1023 int i;
1025 if (freeTokens == NULL) {
1026 freeTokens = (Token *) new_Block(TOKEN_BLOCKSIZE * sizeof(Token));
1027 for (i = 0; i < TOKEN_BLOCKSIZE - 1; i++)
1028 freeTokens[i].next = &freeTokens[i + 1];
1029 freeTokens[i].next = NULL;
1031 t = freeTokens;
1032 freeTokens = t->next;
1033 t->next = next;
1034 t->a.mac = NULL;
1035 t->type = type;
1036 if (type == TOK_WHITESPACE || text == NULL) {
1037 t->text = NULL;
1038 } else {
1039 if (txtlen == 0)
1040 txtlen = strlen(text);
1041 t->text = nasm_malloc(txtlen+1);
1042 memcpy(t->text, text, txtlen);
1043 t->text[txtlen] = '\0';
1045 return t;
1048 static Token *delete_Token(Token * t)
1050 Token *next = t->next;
1051 nasm_free(t->text);
1052 t->next = freeTokens;
1053 freeTokens = t;
1054 return next;
1058 * Convert a line of tokens back into text.
1059 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1060 * will be transformed into ..@ctxnum.xxx
1062 static char *detoken(Token * tlist, bool expand_locals)
1064 Token *t;
1065 int len;
1066 char *line, *p;
1067 const char *q;
1069 len = 0;
1070 for (t = tlist; t; t = t->next) {
1071 if (t->type == TOK_PREPROC_ID && t->text[1] == '!') {
1072 char *p = getenv(t->text + 2);
1073 nasm_free(t->text);
1074 if (p)
1075 t->text = nasm_strdup(p);
1076 else
1077 t->text = NULL;
1079 /* Expand local macros here and not during preprocessing */
1080 if (expand_locals &&
1081 t->type == TOK_PREPROC_ID && t->text &&
1082 t->text[0] == '%' && t->text[1] == '$') {
1083 Context *ctx = get_ctx(t->text, false);
1084 if (ctx) {
1085 char buffer[40];
1086 char *p, *q = t->text + 2;
1088 q += strspn(q, "$");
1089 snprintf(buffer, sizeof(buffer), "..@%"PRIu32".", ctx->number);
1090 p = nasm_strcat(buffer, q);
1091 nasm_free(t->text);
1092 t->text = p;
1095 if (t->type == TOK_WHITESPACE) {
1096 len++;
1097 } else if (t->text) {
1098 len += strlen(t->text);
1101 p = line = nasm_malloc(len + 1);
1102 for (t = tlist; t; t = t->next) {
1103 if (t->type == TOK_WHITESPACE) {
1104 *p++ = ' ';
1105 } else if (t->text) {
1106 q = t->text;
1107 while (*q)
1108 *p++ = *q++;
1111 *p = '\0';
1112 return line;
1116 * A scanner, suitable for use by the expression evaluator, which
1117 * operates on a line of Tokens. Expects a pointer to a pointer to
1118 * the first token in the line to be passed in as its private_data
1119 * field.
1121 * FIX: This really needs to be unified with stdscan.
1123 static int ppscan(void *private_data, struct tokenval *tokval)
1125 Token **tlineptr = private_data;
1126 Token *tline;
1127 char ourcopy[MAX_KEYWORD+1], *p, *r, *s;
1129 do {
1130 tline = *tlineptr;
1131 *tlineptr = tline ? tline->next : NULL;
1133 while (tline && (tline->type == TOK_WHITESPACE ||
1134 tline->type == TOK_COMMENT));
1136 if (!tline)
1137 return tokval->t_type = TOKEN_EOS;
1139 tokval->t_charptr = tline->text;
1141 if (tline->text[0] == '$' && !tline->text[1])
1142 return tokval->t_type = TOKEN_HERE;
1143 if (tline->text[0] == '$' && tline->text[1] == '$' && !tline->text[2])
1144 return tokval->t_type = TOKEN_BASE;
1146 if (tline->type == TOK_ID) {
1147 p = tokval->t_charptr = tline->text;
1148 if (p[0] == '$') {
1149 tokval->t_charptr++;
1150 return tokval->t_type = TOKEN_ID;
1153 for (r = p, s = ourcopy; *r; r++) {
1154 if (r >= p+MAX_KEYWORD)
1155 return tokval->t_type = TOKEN_ID; /* Not a keyword */
1156 *s++ = nasm_tolower(*r);
1158 *s = '\0';
1159 /* right, so we have an identifier sitting in temp storage. now,
1160 * is it actually a register or instruction name, or what? */
1161 return nasm_token_hash(ourcopy, tokval);
1164 if (tline->type == TOK_NUMBER) {
1165 bool rn_error;
1166 tokval->t_integer = readnum(tline->text, &rn_error);
1167 tokval->t_charptr = tline->text;
1168 if (rn_error)
1169 return tokval->t_type = TOKEN_ERRNUM;
1170 else
1171 return tokval->t_type = TOKEN_NUM;
1174 if (tline->type == TOK_FLOAT) {
1175 return tokval->t_type = TOKEN_FLOAT;
1178 if (tline->type == TOK_STRING) {
1179 char bq, *ep;
1181 bq = tline->text[0];
1182 tokval->t_charptr = tline->text;
1183 tokval->t_inttwo = nasm_unquote(tline->text, &ep);
1185 if (ep[0] != bq || ep[1] != '\0')
1186 return tokval->t_type = TOKEN_ERRSTR;
1187 else
1188 return tokval->t_type = TOKEN_STR;
1191 if (tline->type == TOK_OTHER) {
1192 if (!strcmp(tline->text, "<<"))
1193 return tokval->t_type = TOKEN_SHL;
1194 if (!strcmp(tline->text, ">>"))
1195 return tokval->t_type = TOKEN_SHR;
1196 if (!strcmp(tline->text, "//"))
1197 return tokval->t_type = TOKEN_SDIV;
1198 if (!strcmp(tline->text, "%%"))
1199 return tokval->t_type = TOKEN_SMOD;
1200 if (!strcmp(tline->text, "=="))
1201 return tokval->t_type = TOKEN_EQ;
1202 if (!strcmp(tline->text, "<>"))
1203 return tokval->t_type = TOKEN_NE;
1204 if (!strcmp(tline->text, "!="))
1205 return tokval->t_type = TOKEN_NE;
1206 if (!strcmp(tline->text, "<="))
1207 return tokval->t_type = TOKEN_LE;
1208 if (!strcmp(tline->text, ">="))
1209 return tokval->t_type = TOKEN_GE;
1210 if (!strcmp(tline->text, "&&"))
1211 return tokval->t_type = TOKEN_DBL_AND;
1212 if (!strcmp(tline->text, "^^"))
1213 return tokval->t_type = TOKEN_DBL_XOR;
1214 if (!strcmp(tline->text, "||"))
1215 return tokval->t_type = TOKEN_DBL_OR;
1219 * We have no other options: just return the first character of
1220 * the token text.
1222 return tokval->t_type = tline->text[0];
1226 * Compare a string to the name of an existing macro; this is a
1227 * simple wrapper which calls either strcmp or nasm_stricmp
1228 * depending on the value of the `casesense' parameter.
1230 static int mstrcmp(const char *p, const char *q, bool casesense)
1232 return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
1236 * Compare a string to the name of an existing macro; this is a
1237 * simple wrapper which calls either strcmp or nasm_stricmp
1238 * depending on the value of the `casesense' parameter.
1240 static int mmemcmp(const char *p, const char *q, size_t l, bool casesense)
1242 return casesense ? memcmp(p, q, l) : nasm_memicmp(p, q, l);
1246 * Return the Context structure associated with a %$ token. Return
1247 * NULL, having _already_ reported an error condition, if the
1248 * context stack isn't deep enough for the supplied number of $
1249 * signs.
1250 * If all_contexts == true, contexts that enclose current are
1251 * also scanned for such smacro, until it is found; if not -
1252 * only the context that directly results from the number of $'s
1253 * in variable's name.
1255 static Context *get_ctx(const char *name, bool all_contexts)
1257 Context *ctx;
1258 SMacro *m;
1259 int i;
1261 if (!name || name[0] != '%' || name[1] != '$')
1262 return NULL;
1264 if (!cstk) {
1265 error(ERR_NONFATAL, "`%s': context stack is empty", name);
1266 return NULL;
1269 for (i = strspn(name + 2, "$"), ctx = cstk; (i > 0) && ctx; i--) {
1270 ctx = ctx->next;
1271 /* i--; Lino - 02/25/02 */
1273 if (!ctx) {
1274 error(ERR_NONFATAL, "`%s': context stack is only"
1275 " %d level%s deep", name, i - 1, (i == 2 ? "" : "s"));
1276 return NULL;
1278 if (!all_contexts)
1279 return ctx;
1281 do {
1282 /* Search for this smacro in found context */
1283 m = hash_findix(&ctx->localmac, name);
1284 while (m) {
1285 if (!mstrcmp(m->name, name, m->casesense))
1286 return ctx;
1287 m = m->next;
1289 ctx = ctx->next;
1291 while (ctx);
1292 return NULL;
1296 * Check to see if a file is already in a string list
1298 static bool in_list(const StrList *list, const char *str)
1300 while (list) {
1301 if (!strcmp(list->str, str))
1302 return true;
1303 list = list->next;
1305 return false;
1309 * Open an include file. This routine must always return a valid
1310 * file pointer if it returns - it's responsible for throwing an
1311 * ERR_FATAL and bombing out completely if not. It should also try
1312 * the include path one by one until it finds the file or reaches
1313 * the end of the path.
1315 static FILE *inc_fopen(const char *file, StrList **dhead, StrList ***dtail,
1316 bool missing_ok)
1318 FILE *fp;
1319 char *prefix = "";
1320 IncPath *ip = ipath;
1321 int len = strlen(file);
1322 size_t prefix_len = 0;
1323 StrList *sl;
1325 while (1) {
1326 sl = nasm_malloc(prefix_len+len+1+sizeof sl->next);
1327 memcpy(sl->str, prefix, prefix_len);
1328 memcpy(sl->str+prefix_len, file, len+1);
1329 fp = fopen(sl->str, "r");
1330 if (fp && dhead && !in_list(*dhead, sl->str)) {
1331 sl->next = NULL;
1332 **dtail = sl;
1333 *dtail = &sl->next;
1334 } else {
1335 nasm_free(sl);
1337 if (fp)
1338 return fp;
1339 if (!ip) {
1340 if (!missing_ok)
1341 break;
1342 prefix = NULL;
1343 } else {
1344 prefix = ip->path;
1345 ip = ip->next;
1347 if (prefix) {
1348 prefix_len = strlen(prefix);
1349 } else {
1350 /* -MG given and file not found */
1351 if (dhead && !in_list(*dhead, file)) {
1352 sl = nasm_malloc(len+1+sizeof sl->next);
1353 sl->next = NULL;
1354 strcpy(sl->str, file);
1355 **dtail = sl;
1356 *dtail = &sl->next;
1358 return NULL;
1362 error(ERR_FATAL, "unable to open include file `%s'", file);
1363 return NULL; /* never reached - placate compilers */
1367 * Determine if we should warn on defining a single-line macro of
1368 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1369 * return true if _any_ single-line macro of that name is defined.
1370 * Otherwise, will return true if a single-line macro with either
1371 * `nparam' or no parameters is defined.
1373 * If a macro with precisely the right number of parameters is
1374 * defined, or nparam is -1, the address of the definition structure
1375 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1376 * is NULL, no action will be taken regarding its contents, and no
1377 * error will occur.
1379 * Note that this is also called with nparam zero to resolve
1380 * `ifdef'.
1382 * If you already know which context macro belongs to, you can pass
1383 * the context pointer as first parameter; if you won't but name begins
1384 * with %$ the context will be automatically computed. If all_contexts
1385 * is true, macro will be searched in outer contexts as well.
1387 static bool
1388 smacro_defined(Context * ctx, const char *name, int nparam, SMacro ** defn,
1389 bool nocase)
1391 struct hash_table *smtbl;
1392 SMacro *m;
1394 if (ctx) {
1395 smtbl = &ctx->localmac;
1396 } else if (name[0] == '%' && name[1] == '$') {
1397 if (cstk)
1398 ctx = get_ctx(name, false);
1399 if (!ctx)
1400 return false; /* got to return _something_ */
1401 smtbl = &ctx->localmac;
1402 } else {
1403 smtbl = &smacros;
1405 m = (SMacro *) hash_findix(smtbl, name);
1407 while (m) {
1408 if (!mstrcmp(m->name, name, m->casesense && nocase) &&
1409 (nparam <= 0 || m->nparam == 0 || nparam == (int) m->nparam)) {
1410 if (defn) {
1411 if (nparam == (int) m->nparam || nparam == -1)
1412 *defn = m;
1413 else
1414 *defn = NULL;
1416 return true;
1418 m = m->next;
1421 return false;
1425 * Count and mark off the parameters in a multi-line macro call.
1426 * This is called both from within the multi-line macro expansion
1427 * code, and also to mark off the default parameters when provided
1428 * in a %macro definition line.
1430 static void count_mmac_params(Token * t, int *nparam, Token *** params)
1432 int paramsize, brace;
1434 *nparam = paramsize = 0;
1435 *params = NULL;
1436 while (t) {
1437 if (*nparam >= paramsize) {
1438 paramsize += PARAM_DELTA;
1439 *params = nasm_realloc(*params, sizeof(**params) * paramsize);
1441 skip_white_(t);
1442 brace = false;
1443 if (tok_is_(t, "{"))
1444 brace = true;
1445 (*params)[(*nparam)++] = t;
1446 while (tok_isnt_(t, brace ? "}" : ","))
1447 t = t->next;
1448 if (t) { /* got a comma/brace */
1449 t = t->next;
1450 if (brace) {
1452 * Now we've found the closing brace, look further
1453 * for the comma.
1455 skip_white_(t);
1456 if (tok_isnt_(t, ",")) {
1457 error(ERR_NONFATAL,
1458 "braces do not enclose all of macro parameter");
1459 while (tok_isnt_(t, ","))
1460 t = t->next;
1462 if (t)
1463 t = t->next; /* eat the comma */
1470 * Determine whether one of the various `if' conditions is true or
1471 * not.
1473 * We must free the tline we get passed.
1475 static bool if_condition(Token * tline, enum preproc_token ct)
1477 enum pp_conditional i = PP_COND(ct);
1478 bool j;
1479 Token *t, *tt, **tptr, *origline;
1480 struct tokenval tokval;
1481 expr *evalresult;
1482 enum pp_token_type needtype;
1484 origline = tline;
1486 switch (i) {
1487 case PPC_IFCTX:
1488 j = false; /* have we matched yet? */
1489 while (cstk && tline) {
1490 skip_white_(tline);
1491 if (!tline || tline->type != TOK_ID) {
1492 error(ERR_NONFATAL,
1493 "`%s' expects context identifiers", pp_directives[ct]);
1494 free_tlist(origline);
1495 return -1;
1497 if (cstk->name && !nasm_stricmp(tline->text, cstk->name))
1498 j = true;
1499 tline = tline->next;
1501 break;
1503 case PPC_IFDEF:
1504 j = false; /* have we matched yet? */
1505 while (tline) {
1506 skip_white_(tline);
1507 if (!tline || (tline->type != TOK_ID &&
1508 (tline->type != TOK_PREPROC_ID ||
1509 tline->text[1] != '$'))) {
1510 error(ERR_NONFATAL,
1511 "`%s' expects macro identifiers", pp_directives[ct]);
1512 goto fail;
1514 if (smacro_defined(NULL, tline->text, 0, NULL, true))
1515 j = true;
1516 tline = tline->next;
1518 break;
1520 case PPC_IFIDN:
1521 case PPC_IFIDNI:
1522 tline = expand_smacro(tline);
1523 t = tt = tline;
1524 while (tok_isnt_(tt, ","))
1525 tt = tt->next;
1526 if (!tt) {
1527 error(ERR_NONFATAL,
1528 "`%s' expects two comma-separated arguments",
1529 pp_directives[ct]);
1530 goto fail;
1532 tt = tt->next;
1533 j = true; /* assume equality unless proved not */
1534 while ((t->type != TOK_OTHER || strcmp(t->text, ",")) && tt) {
1535 if (tt->type == TOK_OTHER && !strcmp(tt->text, ",")) {
1536 error(ERR_NONFATAL, "`%s': more than one comma on line",
1537 pp_directives[ct]);
1538 goto fail;
1540 if (t->type == TOK_WHITESPACE) {
1541 t = t->next;
1542 continue;
1544 if (tt->type == TOK_WHITESPACE) {
1545 tt = tt->next;
1546 continue;
1548 if (tt->type != t->type) {
1549 j = false; /* found mismatching tokens */
1550 break;
1552 /* When comparing strings, need to unquote them first */
1553 if (t->type == TOK_STRING) {
1554 size_t l1 = nasm_unquote(t->text, NULL);
1555 size_t l2 = nasm_unquote(tt->text, NULL);
1557 if (l1 != l2) {
1558 j = false;
1559 break;
1561 if (mmemcmp(t->text, tt->text, l1, i == PPC_IFIDN)) {
1562 j = false;
1563 break;
1565 } else if (mstrcmp(tt->text, t->text, i == PPC_IFIDN) != 0) {
1566 j = false; /* found mismatching tokens */
1567 break;
1570 t = t->next;
1571 tt = tt->next;
1573 if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
1574 j = false; /* trailing gunk on one end or other */
1575 break;
1577 case PPC_IFMACRO:
1579 bool found = false;
1580 MMacro searching, *mmac;
1582 tline = tline->next;
1583 skip_white_(tline);
1584 tline = expand_id(tline);
1585 if (!tok_type_(tline, TOK_ID)) {
1586 error(ERR_NONFATAL,
1587 "`%s' expects a macro name", pp_directives[ct]);
1588 goto fail;
1590 searching.name = nasm_strdup(tline->text);
1591 searching.casesense = true;
1592 searching.plus = false;
1593 searching.nolist = false;
1594 searching.in_progress = 0;
1595 searching.rep_nest = NULL;
1596 searching.nparam_min = 0;
1597 searching.nparam_max = INT_MAX;
1598 tline = expand_smacro(tline->next);
1599 skip_white_(tline);
1600 if (!tline) {
1601 } else if (!tok_type_(tline, TOK_NUMBER)) {
1602 error(ERR_NONFATAL,
1603 "`%s' expects a parameter count or nothing",
1604 pp_directives[ct]);
1605 } else {
1606 searching.nparam_min = searching.nparam_max =
1607 readnum(tline->text, &j);
1608 if (j)
1609 error(ERR_NONFATAL,
1610 "unable to parse parameter count `%s'",
1611 tline->text);
1613 if (tline && tok_is_(tline->next, "-")) {
1614 tline = tline->next->next;
1615 if (tok_is_(tline, "*"))
1616 searching.nparam_max = INT_MAX;
1617 else if (!tok_type_(tline, TOK_NUMBER))
1618 error(ERR_NONFATAL,
1619 "`%s' expects a parameter count after `-'",
1620 pp_directives[ct]);
1621 else {
1622 searching.nparam_max = readnum(tline->text, &j);
1623 if (j)
1624 error(ERR_NONFATAL,
1625 "unable to parse parameter count `%s'",
1626 tline->text);
1627 if (searching.nparam_min > searching.nparam_max)
1628 error(ERR_NONFATAL,
1629 "minimum parameter count exceeds maximum");
1632 if (tline && tok_is_(tline->next, "+")) {
1633 tline = tline->next;
1634 searching.plus = true;
1636 mmac = (MMacro *) hash_findix(&mmacros, searching.name);
1637 while (mmac) {
1638 if (!strcmp(mmac->name, searching.name) &&
1639 (mmac->nparam_min <= searching.nparam_max
1640 || searching.plus)
1641 && (searching.nparam_min <= mmac->nparam_max
1642 || mmac->plus)) {
1643 found = true;
1644 break;
1646 mmac = mmac->next;
1648 nasm_free(searching.name);
1649 j = found;
1650 break;
1653 case PPC_IFID:
1654 needtype = TOK_ID;
1655 goto iftype;
1656 case PPC_IFNUM:
1657 needtype = TOK_NUMBER;
1658 goto iftype;
1659 case PPC_IFSTR:
1660 needtype = TOK_STRING;
1661 goto iftype;
1663 iftype:
1664 t = tline = expand_smacro(tline);
1666 while (tok_type_(t, TOK_WHITESPACE) ||
1667 (needtype == TOK_NUMBER &&
1668 tok_type_(t, TOK_OTHER) &&
1669 (t->text[0] == '-' || t->text[0] == '+') &&
1670 !t->text[1]))
1671 t = t->next;
1673 j = tok_type_(t, needtype);
1674 break;
1676 case PPC_IFTOKEN:
1677 t = tline = expand_smacro(tline);
1678 while (tok_type_(t, TOK_WHITESPACE))
1679 t = t->next;
1681 j = false;
1682 if (t) {
1683 t = t->next; /* Skip the actual token */
1684 while (tok_type_(t, TOK_WHITESPACE))
1685 t = t->next;
1686 j = !t; /* Should be nothing left */
1688 break;
1690 case PPC_IFEMPTY:
1691 t = tline = expand_smacro(tline);
1692 while (tok_type_(t, TOK_WHITESPACE))
1693 t = t->next;
1695 j = !t; /* Should be empty */
1696 break;
1698 case PPC_IF:
1699 t = tline = expand_smacro(tline);
1700 tptr = &t;
1701 tokval.t_type = TOKEN_INVALID;
1702 evalresult = evaluate(ppscan, tptr, &tokval,
1703 NULL, pass | CRITICAL, error, NULL);
1704 if (!evalresult)
1705 return -1;
1706 if (tokval.t_type)
1707 error(ERR_WARNING,
1708 "trailing garbage after expression ignored");
1709 if (!is_simple(evalresult)) {
1710 error(ERR_NONFATAL,
1711 "non-constant value given to `%s'", pp_directives[ct]);
1712 goto fail;
1714 j = reloc_value(evalresult) != 0;
1715 return j;
1717 default:
1718 error(ERR_FATAL,
1719 "preprocessor directive `%s' not yet implemented",
1720 pp_directives[ct]);
1721 goto fail;
1724 free_tlist(origline);
1725 return j ^ PP_NEGATIVE(ct);
1727 fail:
1728 free_tlist(origline);
1729 return -1;
1733 * Common code for defining an smacro
1735 static bool define_smacro(Context *ctx, char *mname, bool casesense,
1736 int nparam, Token *expansion)
1738 SMacro *smac, **smhead;
1739 struct hash_table *smtbl;
1741 if (smacro_defined(ctx, mname, nparam, &smac, casesense)) {
1742 if (!smac) {
1743 error(ERR_WARNING,
1744 "single-line macro `%s' defined both with and"
1745 " without parameters", mname);
1747 /* Some instances of the old code considered this a failure,
1748 some others didn't. What is the right thing to do here? */
1749 free_tlist(expansion);
1750 return false; /* Failure */
1751 } else {
1753 * We're redefining, so we have to take over an
1754 * existing SMacro structure. This means freeing
1755 * what was already in it.
1757 nasm_free(smac->name);
1758 free_tlist(smac->expansion);
1760 } else {
1761 smtbl = ctx ? &ctx->localmac : &smacros;
1762 smhead = (SMacro **) hash_findi_add(smtbl, mname);
1763 smac = nasm_malloc(sizeof(SMacro));
1764 smac->next = *smhead;
1765 *smhead = smac;
1767 smac->name = nasm_strdup(mname);
1768 smac->casesense = casesense;
1769 smac->nparam = nparam;
1770 smac->expansion = expansion;
1771 smac->in_progress = false;
1772 return true; /* Success */
1776 * Undefine an smacro
1778 static void undef_smacro(Context *ctx, const char *mname)
1780 SMacro **smhead, *s, **sp;
1781 struct hash_table *smtbl;
1783 smtbl = ctx ? &ctx->localmac : &smacros;
1784 smhead = (SMacro **)hash_findi(smtbl, mname, NULL);
1786 if (smhead) {
1788 * We now have a macro name... go hunt for it.
1790 sp = smhead;
1791 while ((s = *sp) != NULL) {
1792 if (!mstrcmp(s->name, mname, s->casesense)) {
1793 *sp = s->next;
1794 nasm_free(s->name);
1795 free_tlist(s->expansion);
1796 nasm_free(s);
1797 } else {
1798 sp = &s->next;
1805 * Decode a size directive
1807 static int parse_size(const char *str) {
1808 static const char *size_names[] =
1809 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
1810 static const int sizes[] =
1811 { 0, 1, 4, 16, 8, 10, 2, 32 };
1813 return sizes[bsii(str, size_names, elements(size_names))+1];
1817 * find and process preprocessor directive in passed line
1818 * Find out if a line contains a preprocessor directive, and deal
1819 * with it if so.
1821 * If a directive _is_ found, it is the responsibility of this routine
1822 * (and not the caller) to free_tlist() the line.
1824 * @param tline a pointer to the current tokeninzed line linked list
1825 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
1828 static int do_directive(Token * tline)
1830 enum preproc_token i;
1831 int j;
1832 bool err;
1833 int nparam;
1834 bool nolist;
1835 bool casesense;
1836 int k, m;
1837 int offset;
1838 char *p, *pp, *mname;
1839 Include *inc;
1840 Context *ctx;
1841 Cond *cond;
1842 MMacro *mmac, **mmhead;
1843 Token *t, *tt, *param_start, *macro_start, *last, **tptr, *origline;
1844 Line *l;
1845 struct tokenval tokval;
1846 expr *evalresult;
1847 MMacro *tmp_defining; /* Used when manipulating rep_nest */
1848 int64_t count;
1849 size_t len;
1851 origline = tline;
1853 skip_white_(tline);
1854 if (!tline || !tok_type_(tline, TOK_PREPROC_ID) ||
1855 (tline->text[1] == '%' || tline->text[1] == '$'
1856 || tline->text[1] == '!'))
1857 return NO_DIRECTIVE_FOUND;
1859 i = pp_token_hash(tline->text);
1862 * If we're in a non-emitting branch of a condition construct,
1863 * or walking to the end of an already terminated %rep block,
1864 * we should ignore all directives except for condition
1865 * directives.
1867 if (((istk->conds && !emitting(istk->conds->state)) ||
1868 (istk->mstk && !istk->mstk->in_progress)) && !is_condition(i)) {
1869 return NO_DIRECTIVE_FOUND;
1873 * If we're defining a macro or reading a %rep block, we should
1874 * ignore all directives except for %macro/%imacro (which
1875 * generate an error), %endm/%endmacro, and (only if we're in a
1876 * %rep block) %endrep. If we're in a %rep block, another %rep
1877 * causes an error, so should be let through.
1879 if (defining && i != PP_MACRO && i != PP_IMACRO &&
1880 i != PP_ENDMACRO && i != PP_ENDM &&
1881 (defining->name || (i != PP_ENDREP && i != PP_REP))) {
1882 return NO_DIRECTIVE_FOUND;
1885 if (defining) {
1886 if (i == PP_MACRO || i == PP_IMACRO) {
1887 nested_mac_count++;
1888 return NO_DIRECTIVE_FOUND;
1889 } else if (nested_mac_count > 0) {
1890 if (i == PP_ENDMACRO) {
1891 nested_mac_count--;
1892 return NO_DIRECTIVE_FOUND;
1895 if (!defining->name) {
1896 if (i == PP_REP) {
1897 nested_rep_count++;
1898 return NO_DIRECTIVE_FOUND;
1899 } else if (nested_rep_count > 0) {
1900 if (i == PP_ENDREP) {
1901 nested_rep_count--;
1902 return NO_DIRECTIVE_FOUND;
1908 switch (i) {
1909 case PP_INVALID:
1910 error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
1911 tline->text);
1912 return NO_DIRECTIVE_FOUND; /* didn't get it */
1914 case PP_STACKSIZE:
1915 /* Directive to tell NASM what the default stack size is. The
1916 * default is for a 16-bit stack, and this can be overriden with
1917 * %stacksize large.
1918 * the following form:
1920 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1922 tline = tline->next;
1923 if (tline && tline->type == TOK_WHITESPACE)
1924 tline = tline->next;
1925 if (!tline || tline->type != TOK_ID) {
1926 error(ERR_NONFATAL, "`%%stacksize' missing size parameter");
1927 free_tlist(origline);
1928 return DIRECTIVE_FOUND;
1930 if (nasm_stricmp(tline->text, "flat") == 0) {
1931 /* All subsequent ARG directives are for a 32-bit stack */
1932 StackSize = 4;
1933 StackPointer = "ebp";
1934 ArgOffset = 8;
1935 LocalOffset = 0;
1936 } else if (nasm_stricmp(tline->text, "flat64") == 0) {
1937 /* All subsequent ARG directives are for a 64-bit stack */
1938 StackSize = 8;
1939 StackPointer = "rbp";
1940 ArgOffset = 8;
1941 LocalOffset = 0;
1942 } else if (nasm_stricmp(tline->text, "large") == 0) {
1943 /* All subsequent ARG directives are for a 16-bit stack,
1944 * far function call.
1946 StackSize = 2;
1947 StackPointer = "bp";
1948 ArgOffset = 4;
1949 LocalOffset = 0;
1950 } else if (nasm_stricmp(tline->text, "small") == 0) {
1951 /* All subsequent ARG directives are for a 16-bit stack,
1952 * far function call. We don't support near functions.
1954 StackSize = 2;
1955 StackPointer = "bp";
1956 ArgOffset = 6;
1957 LocalOffset = 0;
1958 } else {
1959 error(ERR_NONFATAL, "`%%stacksize' invalid size type");
1960 free_tlist(origline);
1961 return DIRECTIVE_FOUND;
1963 free_tlist(origline);
1964 return DIRECTIVE_FOUND;
1966 case PP_ARG:
1967 /* TASM like ARG directive to define arguments to functions, in
1968 * the following form:
1970 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1972 offset = ArgOffset;
1973 do {
1974 char *arg, directive[256];
1975 int size = StackSize;
1977 /* Find the argument name */
1978 tline = tline->next;
1979 if (tline && tline->type == TOK_WHITESPACE)
1980 tline = tline->next;
1981 if (!tline || tline->type != TOK_ID) {
1982 error(ERR_NONFATAL, "`%%arg' missing argument parameter");
1983 free_tlist(origline);
1984 return DIRECTIVE_FOUND;
1986 arg = tline->text;
1988 /* Find the argument size type */
1989 tline = tline->next;
1990 if (!tline || tline->type != TOK_OTHER
1991 || tline->text[0] != ':') {
1992 error(ERR_NONFATAL,
1993 "Syntax error processing `%%arg' directive");
1994 free_tlist(origline);
1995 return DIRECTIVE_FOUND;
1997 tline = tline->next;
1998 if (!tline || tline->type != TOK_ID) {
1999 error(ERR_NONFATAL, "`%%arg' missing size type parameter");
2000 free_tlist(origline);
2001 return DIRECTIVE_FOUND;
2004 /* Allow macro expansion of type parameter */
2005 tt = tokenize(tline->text);
2006 tt = expand_smacro(tt);
2007 size = parse_size(tt->text);
2008 if (!size) {
2009 error(ERR_NONFATAL,
2010 "Invalid size type for `%%arg' missing directive");
2011 free_tlist(tt);
2012 free_tlist(origline);
2013 return DIRECTIVE_FOUND;
2015 free_tlist(tt);
2017 /* Round up to even stack slots */
2018 size = (size+StackSize-1) & ~(StackSize-1);
2020 /* Now define the macro for the argument */
2021 snprintf(directive, sizeof(directive), "%%define %s (%s+%d)",
2022 arg, StackPointer, offset);
2023 do_directive(tokenize(directive));
2024 offset += size;
2026 /* Move to the next argument in the list */
2027 tline = tline->next;
2028 if (tline && tline->type == TOK_WHITESPACE)
2029 tline = tline->next;
2030 } while (tline && tline->type == TOK_OTHER && tline->text[0] == ',');
2031 ArgOffset = offset;
2032 free_tlist(origline);
2033 return DIRECTIVE_FOUND;
2035 case PP_LOCAL:
2036 /* TASM like LOCAL directive to define local variables for a
2037 * function, in the following form:
2039 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2041 * The '= LocalSize' at the end is ignored by NASM, but is
2042 * required by TASM to define the local parameter size (and used
2043 * by the TASM macro package).
2045 offset = LocalOffset;
2046 do {
2047 char *local, directive[256];
2048 int size = StackSize;
2050 /* Find the argument name */
2051 tline = tline->next;
2052 if (tline && tline->type == TOK_WHITESPACE)
2053 tline = tline->next;
2054 if (!tline || tline->type != TOK_ID) {
2055 error(ERR_NONFATAL,
2056 "`%%local' missing argument parameter");
2057 free_tlist(origline);
2058 return DIRECTIVE_FOUND;
2060 local = tline->text;
2062 /* Find the argument size type */
2063 tline = tline->next;
2064 if (!tline || tline->type != TOK_OTHER
2065 || tline->text[0] != ':') {
2066 error(ERR_NONFATAL,
2067 "Syntax error processing `%%local' directive");
2068 free_tlist(origline);
2069 return DIRECTIVE_FOUND;
2071 tline = tline->next;
2072 if (!tline || tline->type != TOK_ID) {
2073 error(ERR_NONFATAL,
2074 "`%%local' missing size type parameter");
2075 free_tlist(origline);
2076 return DIRECTIVE_FOUND;
2079 /* Allow macro expansion of type parameter */
2080 tt = tokenize(tline->text);
2081 tt = expand_smacro(tt);
2082 size = parse_size(tt->text);
2083 if (!size) {
2084 error(ERR_NONFATAL,
2085 "Invalid size type for `%%local' missing directive");
2086 free_tlist(tt);
2087 free_tlist(origline);
2088 return DIRECTIVE_FOUND;
2090 free_tlist(tt);
2092 /* Round up to even stack slots */
2093 size = (size+StackSize-1) & ~(StackSize-1);
2095 offset += size; /* Negative offset, increment before */
2097 /* Now define the macro for the argument */
2098 snprintf(directive, sizeof(directive), "%%define %s (%s-%d)",
2099 local, StackPointer, offset);
2100 do_directive(tokenize(directive));
2102 /* Now define the assign to setup the enter_c macro correctly */
2103 snprintf(directive, sizeof(directive),
2104 "%%assign %%$localsize %%$localsize+%d", size);
2105 do_directive(tokenize(directive));
2107 /* Move to the next argument in the list */
2108 tline = tline->next;
2109 if (tline && tline->type == TOK_WHITESPACE)
2110 tline = tline->next;
2111 } while (tline && tline->type == TOK_OTHER && tline->text[0] == ',');
2112 LocalOffset = offset;
2113 free_tlist(origline);
2114 return DIRECTIVE_FOUND;
2116 case PP_CLEAR:
2117 if (tline->next)
2118 error(ERR_WARNING, "trailing garbage after `%%clear' ignored");
2119 free_macros();
2120 init_macros();
2121 free_tlist(origline);
2122 return DIRECTIVE_FOUND;
2124 case PP_DEPEND:
2125 t = tline->next = expand_smacro(tline->next);
2126 skip_white_(t);
2127 if (!t || (t->type != TOK_STRING &&
2128 t->type != TOK_INTERNAL_STRING)) {
2129 error(ERR_NONFATAL, "`%%depend' expects a file name");
2130 free_tlist(origline);
2131 return DIRECTIVE_FOUND; /* but we did _something_ */
2133 if (t->next)
2134 error(ERR_WARNING,
2135 "trailing garbage after `%%depend' ignored");
2136 p = t->text;
2137 if (t->type != TOK_INTERNAL_STRING)
2138 nasm_unquote(p, NULL);
2139 if (dephead && !in_list(*dephead, p)) {
2140 StrList *sl = nasm_malloc(strlen(p)+1+sizeof sl->next);
2141 sl->next = NULL;
2142 strcpy(sl->str, p);
2143 *deptail = sl;
2144 deptail = &sl->next;
2146 free_tlist(origline);
2147 return DIRECTIVE_FOUND;
2149 case PP_INCLUDE:
2150 t = tline->next = expand_smacro(tline->next);
2151 skip_white_(t);
2153 if (!t || (t->type != TOK_STRING &&
2154 t->type != TOK_INTERNAL_STRING)) {
2155 error(ERR_NONFATAL, "`%%include' expects a file name");
2156 free_tlist(origline);
2157 return DIRECTIVE_FOUND; /* but we did _something_ */
2159 if (t->next)
2160 error(ERR_WARNING,
2161 "trailing garbage after `%%include' ignored");
2162 p = t->text;
2163 if (t->type != TOK_INTERNAL_STRING)
2164 nasm_unquote(p, NULL);
2165 inc = nasm_malloc(sizeof(Include));
2166 inc->next = istk;
2167 inc->conds = NULL;
2168 inc->fp = inc_fopen(p, dephead, &deptail, pass == 0);
2169 if (!inc->fp) {
2170 /* -MG given but file not found */
2171 nasm_free(inc);
2172 } else {
2173 inc->fname = src_set_fname(nasm_strdup(p));
2174 inc->lineno = src_set_linnum(0);
2175 inc->lineinc = 1;
2176 inc->expansion = NULL;
2177 inc->mstk = NULL;
2178 istk = inc;
2179 list->uplevel(LIST_INCLUDE);
2181 free_tlist(origline);
2182 return DIRECTIVE_FOUND;
2184 case PP_USE:
2186 static const macros_t *use_pkg;
2187 const char *pkg_macro;
2189 t = tline->next = expand_smacro(tline->next);
2190 skip_white_(t);
2192 if (!t || (t->type != TOK_STRING &&
2193 t->type != TOK_INTERNAL_STRING &&
2194 t->type != TOK_ID)) {
2195 error(ERR_NONFATAL, "`%%use' expects a package name");
2196 free_tlist(origline);
2197 return DIRECTIVE_FOUND; /* but we did _something_ */
2199 if (t->next)
2200 error(ERR_WARNING,
2201 "trailing garbage after `%%use' ignored");
2202 if (t->type == TOK_STRING)
2203 nasm_unquote(t->text, NULL);
2204 use_pkg = nasm_stdmac_find_package(t->text);
2205 if (!use_pkg)
2206 error(ERR_NONFATAL, "unknown `%%use' package: %s", t->text);
2207 /* The first string will be <%define>__USE_*__ */
2208 pkg_macro = (char *)use_pkg + 1;
2209 if (!smacro_defined(NULL, pkg_macro, 0, NULL, true)) {
2210 /* Not already included, go ahead and include it */
2211 stdmacpos = use_pkg;
2213 free_tlist(origline);
2214 return DIRECTIVE_FOUND;
2216 case PP_PUSH:
2217 tline = tline->next;
2218 skip_white_(tline);
2219 tline = expand_id(tline);
2220 if (tline) {
2221 if (!tok_type_(tline, TOK_ID)) {
2222 error(ERR_NONFATAL, "`%%push' expects a context identifier");
2223 free_tlist(origline);
2224 return DIRECTIVE_FOUND; /* but we did _something_ */
2226 if (tline->next)
2227 error(ERR_WARNING, "trailing garbage after `%%push' ignored");
2228 p = nasm_strdup(tline->text);
2229 } else {
2230 p = NULL; /* Anonymous context */
2232 ctx = nasm_malloc(sizeof(Context));
2233 ctx->next = cstk;
2234 hash_init(&ctx->localmac, HASH_SMALL);
2235 ctx->name = p;
2236 ctx->number = unique++;
2237 cstk = ctx;
2238 free_tlist(origline);
2239 break;
2241 case PP_REPL:
2242 tline = tline->next;
2243 skip_white_(tline);
2244 tline = expand_id(tline);
2245 if (tline) {
2246 if (!tok_type_(tline, TOK_ID)) {
2247 error(ERR_NONFATAL, "`%%repl' expects a context identifier");
2248 free_tlist(origline);
2249 return DIRECTIVE_FOUND; /* but we did _something_ */
2251 if (tline->next)
2252 error(ERR_WARNING, "trailing garbage after `%%repl' ignored");
2253 p = nasm_strdup(tline->text);
2254 } else {
2255 p = NULL;
2257 if (!cstk)
2258 error(ERR_NONFATAL, "`%%repl': context stack is empty");
2259 else {
2260 nasm_free(cstk->name);
2261 cstk->name = p;
2263 free_tlist(origline);
2264 break;
2266 case PP_POP:
2267 if (tline->next)
2268 error(ERR_WARNING, "trailing garbage after `%%pop' ignored");
2269 if (!cstk)
2270 error(ERR_NONFATAL, "`%%pop': context stack is already empty");
2271 else
2272 ctx_pop();
2273 free_tlist(origline);
2274 break;
2276 case PP_ERROR:
2277 case PP_WARNING:
2279 int severity = (i == PP_ERROR)
2280 ? ERR_NONFATAL|ERR_NO_SEVERITY
2281 : ERR_WARNING|ERR_NO_SEVERITY;
2283 tline->next = expand_smacro(tline->next);
2284 tline = tline->next;
2285 skip_white_(tline);
2286 t = tline ? tline->next : NULL;
2287 skip_white_(t);
2288 if (tok_type_(tline, TOK_STRING) && !t) {
2289 /* The line contains only a quoted string */
2290 p = tline->text;
2291 nasm_unquote(p, NULL);
2292 error(severity, "%s: %s", pp_directives[i], p);
2293 } else {
2294 /* Not a quoted string, or more than a quoted string */
2295 p = detoken(tline, false);
2296 error(severity, "%s: %s", pp_directives[i], p);
2297 nasm_free(p);
2299 free_tlist(origline);
2300 break;
2303 CASE_PP_IF:
2304 if (istk->conds && !emitting(istk->conds->state))
2305 j = COND_NEVER;
2306 else {
2307 j = if_condition(tline->next, i);
2308 tline->next = NULL; /* it got freed */
2309 j = j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2311 cond = nasm_malloc(sizeof(Cond));
2312 cond->next = istk->conds;
2313 cond->state = j;
2314 istk->conds = cond;
2315 free_tlist(origline);
2316 return DIRECTIVE_FOUND;
2318 CASE_PP_ELIF:
2319 if (!istk->conds)
2320 error(ERR_FATAL, "`%s': no matching `%%if'", pp_directives[i]);
2321 if (emitting(istk->conds->state)
2322 || istk->conds->state == COND_NEVER)
2323 istk->conds->state = COND_NEVER;
2324 else {
2326 * IMPORTANT: In the case of %if, we will already have
2327 * called expand_mmac_params(); however, if we're
2328 * processing an %elif we must have been in a
2329 * non-emitting mode, which would have inhibited
2330 * the normal invocation of expand_mmac_params(). Therefore,
2331 * we have to do it explicitly here.
2333 j = if_condition(expand_mmac_params(tline->next), i);
2334 tline->next = NULL; /* it got freed */
2335 istk->conds->state =
2336 j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2338 free_tlist(origline);
2339 return DIRECTIVE_FOUND;
2341 case PP_ELSE:
2342 if (tline->next)
2343 error(ERR_WARNING, "trailing garbage after `%%else' ignored");
2344 if (!istk->conds)
2345 error(ERR_FATAL, "`%%else': no matching `%%if'");
2346 if (emitting(istk->conds->state)
2347 || istk->conds->state == COND_NEVER)
2348 istk->conds->state = COND_ELSE_FALSE;
2349 else
2350 istk->conds->state = COND_ELSE_TRUE;
2351 free_tlist(origline);
2352 return DIRECTIVE_FOUND;
2354 case PP_ENDIF:
2355 if (tline->next)
2356 error(ERR_WARNING, "trailing garbage after `%%endif' ignored");
2357 if (!istk->conds)
2358 error(ERR_FATAL, "`%%endif': no matching `%%if'");
2359 cond = istk->conds;
2360 istk->conds = cond->next;
2361 nasm_free(cond);
2362 free_tlist(origline);
2363 return DIRECTIVE_FOUND;
2365 case PP_MACRO:
2366 case PP_IMACRO:
2367 if (defining)
2368 error(ERR_FATAL,
2369 "`%%%smacro': already defining a macro",
2370 (i == PP_IMACRO ? "i" : ""));
2371 tline = tline->next;
2372 skip_white_(tline);
2373 tline = expand_id(tline);
2374 if (!tok_type_(tline, TOK_ID)) {
2375 error(ERR_NONFATAL,
2376 "`%%%smacro' expects a macro name",
2377 (i == PP_IMACRO ? "i" : ""));
2378 return DIRECTIVE_FOUND;
2380 defining = nasm_malloc(sizeof(MMacro));
2381 defining->name = nasm_strdup(tline->text);
2382 defining->casesense = (i == PP_MACRO);
2383 defining->plus = false;
2384 defining->nolist = false;
2385 defining->in_progress = 0;
2386 defining->rep_nest = NULL;
2387 tline = expand_smacro(tline->next);
2388 skip_white_(tline);
2389 if (!tok_type_(tline, TOK_NUMBER)) {
2390 error(ERR_NONFATAL,
2391 "`%%%smacro' expects a parameter count",
2392 (i == PP_IMACRO ? "i" : ""));
2393 defining->nparam_min = defining->nparam_max = 0;
2394 } else {
2395 defining->nparam_min = defining->nparam_max =
2396 readnum(tline->text, &err);
2397 if (err)
2398 error(ERR_NONFATAL,
2399 "unable to parse parameter count `%s'", tline->text);
2401 if (tline && tok_is_(tline->next, "-")) {
2402 tline = tline->next->next;
2403 if (tok_is_(tline, "*"))
2404 defining->nparam_max = INT_MAX;
2405 else if (!tok_type_(tline, TOK_NUMBER))
2406 error(ERR_NONFATAL,
2407 "`%%%smacro' expects a parameter count after `-'",
2408 (i == PP_IMACRO ? "i" : ""));
2409 else {
2410 defining->nparam_max = readnum(tline->text, &err);
2411 if (err)
2412 error(ERR_NONFATAL,
2413 "unable to parse parameter count `%s'",
2414 tline->text);
2415 if (defining->nparam_min > defining->nparam_max)
2416 error(ERR_NONFATAL,
2417 "minimum parameter count exceeds maximum");
2420 if (tline && tok_is_(tline->next, "+")) {
2421 tline = tline->next;
2422 defining->plus = true;
2424 if (tline && tok_type_(tline->next, TOK_ID) &&
2425 !nasm_stricmp(tline->next->text, ".nolist")) {
2426 tline = tline->next;
2427 defining->nolist = true;
2429 mmac = (MMacro *) hash_findix(&mmacros, defining->name);
2430 while (mmac) {
2431 if (!strcmp(mmac->name, defining->name) &&
2432 (mmac->nparam_min <= defining->nparam_max
2433 || defining->plus)
2434 && (defining->nparam_min <= mmac->nparam_max
2435 || mmac->plus)) {
2436 error(ERR_WARNING,
2437 "redefining multi-line macro `%s'", defining->name);
2438 break;
2440 mmac = mmac->next;
2443 * Handle default parameters.
2445 if (tline && tline->next) {
2446 defining->dlist = tline->next;
2447 tline->next = NULL;
2448 count_mmac_params(defining->dlist, &defining->ndefs,
2449 &defining->defaults);
2450 } else {
2451 defining->dlist = NULL;
2452 defining->defaults = NULL;
2454 defining->expansion = NULL;
2455 free_tlist(origline);
2456 return DIRECTIVE_FOUND;
2458 case PP_ENDM:
2459 case PP_ENDMACRO:
2460 if (!defining) {
2461 error(ERR_NONFATAL, "`%s': not defining a macro", tline->text);
2462 return DIRECTIVE_FOUND;
2464 mmhead = (MMacro **) hash_findi_add(&mmacros, defining->name);
2465 defining->next = *mmhead;
2466 *mmhead = defining;
2467 defining = NULL;
2468 free_tlist(origline);
2469 return DIRECTIVE_FOUND;
2471 case PP_ROTATE:
2472 if (tline->next && tline->next->type == TOK_WHITESPACE)
2473 tline = tline->next;
2474 if (tline->next == NULL) {
2475 free_tlist(origline);
2476 error(ERR_NONFATAL, "`%%rotate' missing rotate count");
2477 return DIRECTIVE_FOUND;
2479 t = expand_smacro(tline->next);
2480 tline->next = NULL;
2481 free_tlist(origline);
2482 tline = t;
2483 tptr = &t;
2484 tokval.t_type = TOKEN_INVALID;
2485 evalresult =
2486 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2487 free_tlist(tline);
2488 if (!evalresult)
2489 return DIRECTIVE_FOUND;
2490 if (tokval.t_type)
2491 error(ERR_WARNING,
2492 "trailing garbage after expression ignored");
2493 if (!is_simple(evalresult)) {
2494 error(ERR_NONFATAL, "non-constant value given to `%%rotate'");
2495 return DIRECTIVE_FOUND;
2497 mmac = istk->mstk;
2498 while (mmac && !mmac->name) /* avoid mistaking %reps for macros */
2499 mmac = mmac->next_active;
2500 if (!mmac) {
2501 error(ERR_NONFATAL, "`%%rotate' invoked outside a macro call");
2502 } else if (mmac->nparam == 0) {
2503 error(ERR_NONFATAL,
2504 "`%%rotate' invoked within macro without parameters");
2505 } else {
2506 int rotate = mmac->rotate + reloc_value(evalresult);
2508 rotate %= (int)mmac->nparam;
2509 if (rotate < 0)
2510 rotate += mmac->nparam;
2512 mmac->rotate = rotate;
2514 return DIRECTIVE_FOUND;
2516 case PP_REP:
2517 nolist = false;
2518 do {
2519 tline = tline->next;
2520 } while (tok_type_(tline, TOK_WHITESPACE));
2522 if (tok_type_(tline, TOK_ID) &&
2523 nasm_stricmp(tline->text, ".nolist") == 0) {
2524 nolist = true;
2525 do {
2526 tline = tline->next;
2527 } while (tok_type_(tline, TOK_WHITESPACE));
2530 if (tline) {
2531 t = expand_smacro(tline);
2532 tptr = &t;
2533 tokval.t_type = TOKEN_INVALID;
2534 evalresult =
2535 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2536 if (!evalresult) {
2537 free_tlist(origline);
2538 return DIRECTIVE_FOUND;
2540 if (tokval.t_type)
2541 error(ERR_WARNING,
2542 "trailing garbage after expression ignored");
2543 if (!is_simple(evalresult)) {
2544 error(ERR_NONFATAL, "non-constant value given to `%%rep'");
2545 return DIRECTIVE_FOUND;
2547 count = reloc_value(evalresult) + 1;
2548 } else {
2549 error(ERR_NONFATAL, "`%%rep' expects a repeat count");
2550 count = 0;
2552 free_tlist(origline);
2554 tmp_defining = defining;
2555 defining = nasm_malloc(sizeof(MMacro));
2556 defining->name = NULL; /* flags this macro as a %rep block */
2557 defining->casesense = false;
2558 defining->plus = false;
2559 defining->nolist = nolist;
2560 defining->in_progress = count;
2561 defining->nparam_min = defining->nparam_max = 0;
2562 defining->defaults = NULL;
2563 defining->dlist = NULL;
2564 defining->expansion = NULL;
2565 defining->next_active = istk->mstk;
2566 defining->rep_nest = tmp_defining;
2567 return DIRECTIVE_FOUND;
2569 case PP_ENDREP:
2570 if (!defining || defining->name) {
2571 error(ERR_NONFATAL, "`%%endrep': no matching `%%rep'");
2572 return DIRECTIVE_FOUND;
2576 * Now we have a "macro" defined - although it has no name
2577 * and we won't be entering it in the hash tables - we must
2578 * push a macro-end marker for it on to istk->expansion.
2579 * After that, it will take care of propagating itself (a
2580 * macro-end marker line for a macro which is really a %rep
2581 * block will cause the macro to be re-expanded, complete
2582 * with another macro-end marker to ensure the process
2583 * continues) until the whole expansion is forcibly removed
2584 * from istk->expansion by a %exitrep.
2586 l = nasm_malloc(sizeof(Line));
2587 l->next = istk->expansion;
2588 l->finishes = defining;
2589 l->first = NULL;
2590 istk->expansion = l;
2592 istk->mstk = defining;
2594 list->uplevel(defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
2595 tmp_defining = defining;
2596 defining = defining->rep_nest;
2597 free_tlist(origline);
2598 return DIRECTIVE_FOUND;
2600 case PP_EXITREP:
2602 * We must search along istk->expansion until we hit a
2603 * macro-end marker for a macro with no name. Then we set
2604 * its `in_progress' flag to 0.
2606 for (l = istk->expansion; l; l = l->next)
2607 if (l->finishes && !l->finishes->name)
2608 break;
2610 if (l)
2611 l->finishes->in_progress = 1;
2612 else
2613 error(ERR_NONFATAL, "`%%exitrep' not within `%%rep' block");
2614 free_tlist(origline);
2615 return DIRECTIVE_FOUND;
2617 case PP_XDEFINE:
2618 case PP_IXDEFINE:
2619 case PP_DEFINE:
2620 case PP_IDEFINE:
2621 casesense = (i == PP_DEFINE || i == PP_XDEFINE);
2623 tline = tline->next;
2624 skip_white_(tline);
2625 tline = expand_id(tline);
2626 if (!tline || (tline->type != TOK_ID &&
2627 (tline->type != TOK_PREPROC_ID ||
2628 tline->text[1] != '$'))) {
2629 error(ERR_NONFATAL, "`%s' expects a macro identifier",
2630 pp_directives[i]);
2631 free_tlist(origline);
2632 return DIRECTIVE_FOUND;
2635 ctx = get_ctx(tline->text, false);
2637 mname = tline->text;
2638 last = tline;
2639 param_start = tline = tline->next;
2640 nparam = 0;
2642 /* Expand the macro definition now for %xdefine and %ixdefine */
2643 if ((i == PP_XDEFINE) || (i == PP_IXDEFINE))
2644 tline = expand_smacro(tline);
2646 if (tok_is_(tline, "(")) {
2648 * This macro has parameters.
2651 tline = tline->next;
2652 while (1) {
2653 skip_white_(tline);
2654 if (!tline) {
2655 error(ERR_NONFATAL, "parameter identifier expected");
2656 free_tlist(origline);
2657 return DIRECTIVE_FOUND;
2659 if (tline->type != TOK_ID) {
2660 error(ERR_NONFATAL,
2661 "`%s': parameter identifier expected",
2662 tline->text);
2663 free_tlist(origline);
2664 return DIRECTIVE_FOUND;
2666 tline->type = TOK_SMAC_PARAM + nparam++;
2667 tline = tline->next;
2668 skip_white_(tline);
2669 if (tok_is_(tline, ",")) {
2670 tline = tline->next;
2671 continue;
2673 if (!tok_is_(tline, ")")) {
2674 error(ERR_NONFATAL,
2675 "`)' expected to terminate macro template");
2676 free_tlist(origline);
2677 return DIRECTIVE_FOUND;
2679 break;
2681 last = tline;
2682 tline = tline->next;
2684 if (tok_type_(tline, TOK_WHITESPACE))
2685 last = tline, tline = tline->next;
2686 macro_start = NULL;
2687 last->next = NULL;
2688 t = tline;
2689 while (t) {
2690 if (t->type == TOK_ID) {
2691 for (tt = param_start; tt; tt = tt->next)
2692 if (tt->type >= TOK_SMAC_PARAM &&
2693 !strcmp(tt->text, t->text))
2694 t->type = tt->type;
2696 tt = t->next;
2697 t->next = macro_start;
2698 macro_start = t;
2699 t = tt;
2702 * Good. We now have a macro name, a parameter count, and a
2703 * token list (in reverse order) for an expansion. We ought
2704 * to be OK just to create an SMacro, store it, and let
2705 * free_tlist have the rest of the line (which we have
2706 * carefully re-terminated after chopping off the expansion
2707 * from the end).
2709 define_smacro(ctx, mname, casesense, nparam, macro_start);
2710 free_tlist(origline);
2711 return DIRECTIVE_FOUND;
2713 case PP_UNDEF:
2714 tline = tline->next;
2715 skip_white_(tline);
2716 tline = expand_id(tline);
2717 if (!tline || (tline->type != TOK_ID &&
2718 (tline->type != TOK_PREPROC_ID ||
2719 tline->text[1] != '$'))) {
2720 error(ERR_NONFATAL, "`%%undef' expects a macro identifier");
2721 free_tlist(origline);
2722 return DIRECTIVE_FOUND;
2724 if (tline->next) {
2725 error(ERR_WARNING,
2726 "trailing garbage after macro name ignored");
2729 /* Find the context that symbol belongs to */
2730 ctx = get_ctx(tline->text, false);
2731 undef_smacro(ctx, tline->text);
2732 free_tlist(origline);
2733 return DIRECTIVE_FOUND;
2735 case PP_DEFSTR:
2736 case PP_IDEFSTR:
2737 casesense = (i == PP_DEFSTR);
2739 tline = tline->next;
2740 skip_white_(tline);
2741 tline = expand_id(tline);
2742 if (!tline || (tline->type != TOK_ID &&
2743 (tline->type != TOK_PREPROC_ID ||
2744 tline->text[1] != '$'))) {
2745 error(ERR_NONFATAL, "`%s' expects a macro identifier",
2746 pp_directives[i]);
2747 free_tlist(origline);
2748 return DIRECTIVE_FOUND;
2751 ctx = get_ctx(tline->text, false);
2753 mname = tline->text;
2754 last = tline;
2755 tline = expand_smacro(tline->next);
2756 last->next = NULL;
2758 while (tok_type_(tline, TOK_WHITESPACE))
2759 tline = delete_Token(tline);
2761 p = detoken(tline, false);
2762 macro_start = nasm_malloc(sizeof(*macro_start));
2763 macro_start->next = NULL;
2764 macro_start->text = nasm_quote(p, strlen(p));
2765 macro_start->type = TOK_STRING;
2766 macro_start->a.mac = NULL;
2767 nasm_free(p);
2770 * We now have a macro name, an implicit parameter count of
2771 * zero, and a string token to use as an expansion. Create
2772 * and store an SMacro.
2774 define_smacro(ctx, mname, casesense, 0, macro_start);
2775 free_tlist(origline);
2776 return DIRECTIVE_FOUND;
2778 case PP_PATHSEARCH:
2780 FILE *fp;
2781 StrList *xsl = NULL;
2782 StrList **xst = &xsl;
2784 casesense = true;
2786 tline = tline->next;
2787 skip_white_(tline);
2788 tline = expand_id(tline);
2789 if (!tline || (tline->type != TOK_ID &&
2790 (tline->type != TOK_PREPROC_ID ||
2791 tline->text[1] != '$'))) {
2792 error(ERR_NONFATAL,
2793 "`%%pathsearch' expects a macro identifier as first parameter");
2794 free_tlist(origline);
2795 return DIRECTIVE_FOUND;
2797 ctx = get_ctx(tline->text, false);
2799 mname = tline->text;
2800 last = tline;
2801 tline = expand_smacro(tline->next);
2802 last->next = NULL;
2804 t = tline;
2805 while (tok_type_(t, TOK_WHITESPACE))
2806 t = t->next;
2808 if (!t || (t->type != TOK_STRING &&
2809 t->type != TOK_INTERNAL_STRING)) {
2810 error(ERR_NONFATAL, "`%%pathsearch' expects a file name");
2811 free_tlist(tline);
2812 free_tlist(origline);
2813 return DIRECTIVE_FOUND; /* but we did _something_ */
2815 if (t->next)
2816 error(ERR_WARNING,
2817 "trailing garbage after `%%pathsearch' ignored");
2818 p = t->text;
2819 if (t->type != TOK_INTERNAL_STRING)
2820 nasm_unquote(p, NULL);
2822 fp = inc_fopen(p, &xsl, &xst, true);
2823 if (fp) {
2824 p = xsl->str;
2825 fclose(fp); /* Don't actually care about the file */
2827 macro_start = nasm_malloc(sizeof(*macro_start));
2828 macro_start->next = NULL;
2829 macro_start->text = nasm_quote(p, strlen(p));
2830 macro_start->type = TOK_STRING;
2831 macro_start->a.mac = NULL;
2832 if (xsl)
2833 nasm_free(xsl);
2836 * We now have a macro name, an implicit parameter count of
2837 * zero, and a string token to use as an expansion. Create
2838 * and store an SMacro.
2840 define_smacro(ctx, mname, casesense, 0, macro_start);
2841 free_tlist(tline);
2842 free_tlist(origline);
2843 return DIRECTIVE_FOUND;
2846 case PP_STRLEN:
2847 casesense = true;
2849 tline = tline->next;
2850 skip_white_(tline);
2851 tline = expand_id(tline);
2852 if (!tline || (tline->type != TOK_ID &&
2853 (tline->type != TOK_PREPROC_ID ||
2854 tline->text[1] != '$'))) {
2855 error(ERR_NONFATAL,
2856 "`%%strlen' expects a macro identifier as first parameter");
2857 free_tlist(origline);
2858 return DIRECTIVE_FOUND;
2860 ctx = get_ctx(tline->text, false);
2862 mname = tline->text;
2863 last = tline;
2864 tline = expand_smacro(tline->next);
2865 last->next = NULL;
2867 t = tline;
2868 while (tok_type_(t, TOK_WHITESPACE))
2869 t = t->next;
2870 /* t should now point to the string */
2871 if (t->type != TOK_STRING) {
2872 error(ERR_NONFATAL,
2873 "`%%strlen` requires string as second parameter");
2874 free_tlist(tline);
2875 free_tlist(origline);
2876 return DIRECTIVE_FOUND;
2879 macro_start = nasm_malloc(sizeof(*macro_start));
2880 macro_start->next = NULL;
2881 make_tok_num(macro_start, nasm_unquote(t->text, NULL));
2882 macro_start->a.mac = NULL;
2885 * We now have a macro name, an implicit parameter count of
2886 * zero, and a numeric token to use as an expansion. Create
2887 * and store an SMacro.
2889 define_smacro(ctx, mname, casesense, 0, macro_start);
2890 free_tlist(tline);
2891 free_tlist(origline);
2892 return DIRECTIVE_FOUND;
2894 case PP_STRCAT:
2895 casesense = true;
2897 tline = tline->next;
2898 skip_white_(tline);
2899 tline = expand_id(tline);
2900 if (!tline || (tline->type != TOK_ID &&
2901 (tline->type != TOK_PREPROC_ID ||
2902 tline->text[1] != '$'))) {
2903 error(ERR_NONFATAL,
2904 "`%%strcat' expects a macro identifier as first parameter");
2905 free_tlist(origline);
2906 return DIRECTIVE_FOUND;
2908 ctx = get_ctx(tline->text, false);
2910 mname = tline->text;
2911 last = tline;
2912 tline = expand_smacro(tline->next);
2913 last->next = NULL;
2915 len = 0;
2916 for (t = tline; t; t = t->next) {
2917 switch (t->type) {
2918 case TOK_WHITESPACE:
2919 break;
2920 case TOK_STRING:
2921 len += t->a.len = nasm_unquote(t->text, NULL);
2922 break;
2923 case TOK_OTHER:
2924 if (!strcmp(t->text, ",")) /* permit comma separators */
2925 break;
2926 /* else fall through */
2927 default:
2928 error(ERR_NONFATAL,
2929 "non-string passed to `%%strcat' (%d)", t->type);
2930 free_tlist(tline);
2931 free_tlist(origline);
2932 return DIRECTIVE_FOUND;
2936 p = pp = nasm_malloc(len);
2937 t = tline;
2938 for (t = tline; t; t = t->next) {
2939 if (t->type == TOK_STRING) {
2940 memcpy(p, t->text, t->a.len);
2941 p += t->a.len;
2946 * We now have a macro name, an implicit parameter count of
2947 * zero, and a numeric token to use as an expansion. Create
2948 * and store an SMacro.
2950 macro_start = new_Token(NULL, TOK_STRING, NULL, 0);
2951 macro_start->text = nasm_quote(pp, len);
2952 nasm_free(pp);
2953 define_smacro(ctx, mname, casesense, 0, macro_start);
2954 free_tlist(tline);
2955 free_tlist(origline);
2956 return DIRECTIVE_FOUND;
2958 case PP_SUBSTR:
2960 int64_t a1, a2;
2961 size_t len;
2963 casesense = true;
2965 tline = tline->next;
2966 skip_white_(tline);
2967 tline = expand_id(tline);
2968 if (!tline || (tline->type != TOK_ID &&
2969 (tline->type != TOK_PREPROC_ID ||
2970 tline->text[1] != '$'))) {
2971 error(ERR_NONFATAL,
2972 "`%%substr' expects a macro identifier as first parameter");
2973 free_tlist(origline);
2974 return DIRECTIVE_FOUND;
2976 ctx = get_ctx(tline->text, false);
2978 mname = tline->text;
2979 last = tline;
2980 tline = expand_smacro(tline->next);
2981 last->next = NULL;
2983 t = tline->next;
2984 while (tok_type_(t, TOK_WHITESPACE))
2985 t = t->next;
2987 /* t should now point to the string */
2988 if (t->type != TOK_STRING) {
2989 error(ERR_NONFATAL,
2990 "`%%substr` requires string as second parameter");
2991 free_tlist(tline);
2992 free_tlist(origline);
2993 return DIRECTIVE_FOUND;
2996 tt = t->next;
2997 tptr = &tt;
2998 tokval.t_type = TOKEN_INVALID;
2999 evalresult = evaluate(ppscan, tptr, &tokval, NULL,
3000 pass, error, NULL);
3001 if (!evalresult) {
3002 free_tlist(tline);
3003 free_tlist(origline);
3004 return DIRECTIVE_FOUND;
3005 } else if (!is_simple(evalresult)) {
3006 error(ERR_NONFATAL, "non-constant value given to `%%substr`");
3007 free_tlist(tline);
3008 free_tlist(origline);
3009 return DIRECTIVE_FOUND;
3011 a1 = evalresult->value-1;
3013 while (tok_type_(tt, TOK_WHITESPACE))
3014 tt = tt->next;
3015 if (!tt) {
3016 a2 = 1; /* Backwards compatibility: one character */
3017 } else {
3018 tokval.t_type = TOKEN_INVALID;
3019 evalresult = evaluate(ppscan, tptr, &tokval, NULL,
3020 pass, error, NULL);
3021 if (!evalresult) {
3022 free_tlist(tline);
3023 free_tlist(origline);
3024 return DIRECTIVE_FOUND;
3025 } else if (!is_simple(evalresult)) {
3026 error(ERR_NONFATAL, "non-constant value given to `%%substr`");
3027 free_tlist(tline);
3028 free_tlist(origline);
3029 return DIRECTIVE_FOUND;
3031 a2 = evalresult->value;
3034 len = nasm_unquote(t->text, NULL);
3035 if (a2 < 0)
3036 a2 = a2+1+len-a1;
3037 if (a1+a2 > (int64_t)len)
3038 a2 = len-a1;
3040 macro_start = nasm_malloc(sizeof(*macro_start));
3041 macro_start->next = NULL;
3042 macro_start->text = nasm_quote((a1 < 0) ? "" : t->text+a1, a2);
3043 macro_start->type = TOK_STRING;
3044 macro_start->a.mac = NULL;
3047 * We now have a macro name, an implicit parameter count of
3048 * zero, and a numeric token to use as an expansion. Create
3049 * and store an SMacro.
3051 define_smacro(ctx, mname, casesense, 0, macro_start);
3052 free_tlist(tline);
3053 free_tlist(origline);
3054 return DIRECTIVE_FOUND;
3057 case PP_ASSIGN:
3058 case PP_IASSIGN:
3059 casesense = (i == PP_ASSIGN);
3061 tline = tline->next;
3062 skip_white_(tline);
3063 tline = expand_id(tline);
3064 if (!tline || (tline->type != TOK_ID &&
3065 (tline->type != TOK_PREPROC_ID ||
3066 tline->text[1] != '$'))) {
3067 error(ERR_NONFATAL,
3068 "`%%%sassign' expects a macro identifier",
3069 (i == PP_IASSIGN ? "i" : ""));
3070 free_tlist(origline);
3071 return DIRECTIVE_FOUND;
3073 ctx = get_ctx(tline->text, false);
3075 mname = tline->text;
3076 last = tline;
3077 tline = expand_smacro(tline->next);
3078 last->next = NULL;
3080 t = tline;
3081 tptr = &t;
3082 tokval.t_type = TOKEN_INVALID;
3083 evalresult =
3084 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
3085 free_tlist(tline);
3086 if (!evalresult) {
3087 free_tlist(origline);
3088 return DIRECTIVE_FOUND;
3091 if (tokval.t_type)
3092 error(ERR_WARNING,
3093 "trailing garbage after expression ignored");
3095 if (!is_simple(evalresult)) {
3096 error(ERR_NONFATAL,
3097 "non-constant value given to `%%%sassign'",
3098 (i == PP_IASSIGN ? "i" : ""));
3099 free_tlist(origline);
3100 return DIRECTIVE_FOUND;
3103 macro_start = nasm_malloc(sizeof(*macro_start));
3104 macro_start->next = NULL;
3105 make_tok_num(macro_start, reloc_value(evalresult));
3106 macro_start->a.mac = NULL;
3109 * We now have a macro name, an implicit parameter count of
3110 * zero, and a numeric token to use as an expansion. Create
3111 * and store an SMacro.
3113 define_smacro(ctx, mname, casesense, 0, macro_start);
3114 free_tlist(origline);
3115 return DIRECTIVE_FOUND;
3117 case PP_LINE:
3119 * Syntax is `%line nnn[+mmm] [filename]'
3121 tline = tline->next;
3122 skip_white_(tline);
3123 if (!tok_type_(tline, TOK_NUMBER)) {
3124 error(ERR_NONFATAL, "`%%line' expects line number");
3125 free_tlist(origline);
3126 return DIRECTIVE_FOUND;
3128 k = readnum(tline->text, &err);
3129 m = 1;
3130 tline = tline->next;
3131 if (tok_is_(tline, "+")) {
3132 tline = tline->next;
3133 if (!tok_type_(tline, TOK_NUMBER)) {
3134 error(ERR_NONFATAL, "`%%line' expects line increment");
3135 free_tlist(origline);
3136 return DIRECTIVE_FOUND;
3138 m = readnum(tline->text, &err);
3139 tline = tline->next;
3141 skip_white_(tline);
3142 src_set_linnum(k);
3143 istk->lineinc = m;
3144 if (tline) {
3145 nasm_free(src_set_fname(detoken(tline, false)));
3147 free_tlist(origline);
3148 return DIRECTIVE_FOUND;
3150 default:
3151 error(ERR_FATAL,
3152 "preprocessor directive `%s' not yet implemented",
3153 pp_directives[i]);
3154 break;
3156 return DIRECTIVE_FOUND;
3160 * Ensure that a macro parameter contains a condition code and
3161 * nothing else. Return the condition code index if so, or -1
3162 * otherwise.
3164 static int find_cc(Token * t)
3166 Token *tt;
3167 int i, j, k, m;
3169 if (!t)
3170 return -1; /* Probably a %+ without a space */
3172 skip_white_(t);
3173 if (t->type != TOK_ID)
3174 return -1;
3175 tt = t->next;
3176 skip_white_(tt);
3177 if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
3178 return -1;
3180 i = -1;
3181 j = elements(conditions);
3182 while (j - i > 1) {
3183 k = (j + i) / 2;
3184 m = nasm_stricmp(t->text, conditions[k]);
3185 if (m == 0) {
3186 i = k;
3187 j = -2;
3188 break;
3189 } else if (m < 0) {
3190 j = k;
3191 } else
3192 i = k;
3194 if (j != -2)
3195 return -1;
3196 return i;
3200 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3201 * %-n) and MMacro-local identifiers (%%foo).
3203 static Token *expand_mmac_params(Token * tline)
3205 Token *t, *tt, **tail, *thead;
3207 tail = &thead;
3208 thead = NULL;
3210 while (tline) {
3211 if (tline->type == TOK_PREPROC_ID &&
3212 (((tline->text[1] == '+' || tline->text[1] == '-')
3213 && tline->text[2]) || tline->text[1] == '%'
3214 || (tline->text[1] >= '0' && tline->text[1] <= '9'))) {
3215 char *text = NULL;
3216 int type = 0, cc; /* type = 0 to placate optimisers */
3217 char tmpbuf[30];
3218 unsigned int n;
3219 int i;
3220 MMacro *mac;
3222 t = tline;
3223 tline = tline->next;
3225 mac = istk->mstk;
3226 while (mac && !mac->name) /* avoid mistaking %reps for macros */
3227 mac = mac->next_active;
3228 if (!mac)
3229 error(ERR_NONFATAL, "`%s': not in a macro call", t->text);
3230 else
3231 switch (t->text[1]) {
3233 * We have to make a substitution of one of the
3234 * forms %1, %-1, %+1, %%foo, %0.
3236 case '0':
3237 type = TOK_NUMBER;
3238 snprintf(tmpbuf, sizeof(tmpbuf), "%d", mac->nparam);
3239 text = nasm_strdup(tmpbuf);
3240 break;
3241 case '%':
3242 type = TOK_ID;
3243 snprintf(tmpbuf, sizeof(tmpbuf), "..@%"PRIu64".",
3244 mac->unique);
3245 text = nasm_strcat(tmpbuf, t->text + 2);
3246 break;
3247 case '-':
3248 n = atoi(t->text + 2) - 1;
3249 if (n >= mac->nparam)
3250 tt = NULL;
3251 else {
3252 if (mac->nparam > 1)
3253 n = (n + mac->rotate) % mac->nparam;
3254 tt = mac->params[n];
3256 cc = find_cc(tt);
3257 if (cc == -1) {
3258 error(ERR_NONFATAL,
3259 "macro parameter %d is not a condition code",
3260 n + 1);
3261 text = NULL;
3262 } else {
3263 type = TOK_ID;
3264 if (inverse_ccs[cc] == -1) {
3265 error(ERR_NONFATAL,
3266 "condition code `%s' is not invertible",
3267 conditions[cc]);
3268 text = NULL;
3269 } else
3270 text =
3271 nasm_strdup(conditions[inverse_ccs[cc]]);
3273 break;
3274 case '+':
3275 n = atoi(t->text + 2) - 1;
3276 if (n >= mac->nparam)
3277 tt = NULL;
3278 else {
3279 if (mac->nparam > 1)
3280 n = (n + mac->rotate) % mac->nparam;
3281 tt = mac->params[n];
3283 cc = find_cc(tt);
3284 if (cc == -1) {
3285 error(ERR_NONFATAL,
3286 "macro parameter %d is not a condition code",
3287 n + 1);
3288 text = NULL;
3289 } else {
3290 type = TOK_ID;
3291 text = nasm_strdup(conditions[cc]);
3293 break;
3294 default:
3295 n = atoi(t->text + 1) - 1;
3296 if (n >= mac->nparam)
3297 tt = NULL;
3298 else {
3299 if (mac->nparam > 1)
3300 n = (n + mac->rotate) % mac->nparam;
3301 tt = mac->params[n];
3303 if (tt) {
3304 for (i = 0; i < mac->paramlen[n]; i++) {
3305 *tail = new_Token(NULL, tt->type, tt->text, 0);
3306 tail = &(*tail)->next;
3307 tt = tt->next;
3310 text = NULL; /* we've done it here */
3311 break;
3313 if (!text) {
3314 delete_Token(t);
3315 } else {
3316 *tail = t;
3317 tail = &t->next;
3318 t->type = type;
3319 nasm_free(t->text);
3320 t->text = text;
3321 t->a.mac = NULL;
3323 continue;
3324 } else {
3325 t = *tail = tline;
3326 tline = tline->next;
3327 t->a.mac = NULL;
3328 tail = &t->next;
3331 *tail = NULL;
3332 t = thead;
3333 for (; t && (tt = t->next) != NULL; t = t->next)
3334 switch (t->type) {
3335 case TOK_WHITESPACE:
3336 if (tt->type == TOK_WHITESPACE) {
3337 t->next = delete_Token(tt);
3339 break;
3340 case TOK_ID:
3341 if (tt->type == TOK_ID || tt->type == TOK_NUMBER) {
3342 char *tmp = nasm_strcat(t->text, tt->text);
3343 nasm_free(t->text);
3344 t->text = tmp;
3345 t->next = delete_Token(tt);
3347 break;
3348 case TOK_NUMBER:
3349 if (tt->type == TOK_NUMBER) {
3350 char *tmp = nasm_strcat(t->text, tt->text);
3351 nasm_free(t->text);
3352 t->text = tmp;
3353 t->next = delete_Token(tt);
3355 break;
3356 default:
3357 break;
3360 return thead;
3364 * Expand all single-line macro calls made in the given line.
3365 * Return the expanded version of the line. The original is deemed
3366 * to be destroyed in the process. (In reality we'll just move
3367 * Tokens from input to output a lot of the time, rather than
3368 * actually bothering to destroy and replicate.)
3370 #define DEADMAN_LIMIT (1 << 20)
3372 static Token *expand_smacro(Token * tline)
3374 Token *t, *tt, *mstart, **tail, *thead;
3375 struct hash_table *smtbl;
3376 SMacro *head = NULL, *m;
3377 Token **params;
3378 int *paramsize;
3379 unsigned int nparam, sparam;
3380 int brackets, rescan;
3381 Token *org_tline = tline;
3382 Context *ctx;
3383 char *mname;
3384 int deadman = DEADMAN_LIMIT;
3387 * Trick: we should avoid changing the start token pointer since it can
3388 * be contained in "next" field of other token. Because of this
3389 * we allocate a copy of first token and work with it; at the end of
3390 * routine we copy it back
3392 if (org_tline) {
3393 tline =
3394 new_Token(org_tline->next, org_tline->type, org_tline->text,
3396 tline->a.mac = org_tline->a.mac;
3397 nasm_free(org_tline->text);
3398 org_tline->text = NULL;
3401 again:
3402 tail = &thead;
3403 thead = NULL;
3405 while (tline) { /* main token loop */
3406 if (!--deadman) {
3407 error(ERR_NONFATAL, "interminable macro recursion");
3408 break;
3411 if ((mname = tline->text)) {
3412 /* if this token is a local macro, look in local context */
3413 ctx = NULL;
3414 smtbl = &smacros;
3415 if (tline->type == TOK_ID || tline->type == TOK_PREPROC_ID) {
3416 ctx = get_ctx(mname, true);
3417 if (ctx)
3418 smtbl = &ctx->localmac;
3420 head = (SMacro *) hash_findix(smtbl, mname);
3423 * We've hit an identifier. As in is_mmacro below, we first
3424 * check whether the identifier is a single-line macro at
3425 * all, then think about checking for parameters if
3426 * necessary.
3428 for (m = head; m; m = m->next)
3429 if (!mstrcmp(m->name, mname, m->casesense))
3430 break;
3431 if (m) {
3432 mstart = tline;
3433 params = NULL;
3434 paramsize = NULL;
3435 if (m->nparam == 0) {
3437 * Simple case: the macro is parameterless. Discard the
3438 * one token that the macro call took, and push the
3439 * expansion back on the to-do stack.
3441 if (!m->expansion) {
3442 if (!strcmp("__FILE__", m->name)) {
3443 int32_t num = 0;
3444 char *file;
3445 src_get(&num, &file);
3446 tline->text = nasm_quote(file, strlen(file));
3447 tline->type = TOK_STRING;
3448 nasm_free(file);
3449 continue;
3451 if (!strcmp("__LINE__", m->name)) {
3452 nasm_free(tline->text);
3453 make_tok_num(tline, src_get_linnum());
3454 continue;
3456 if (!strcmp("__BITS__", m->name)) {
3457 nasm_free(tline->text);
3458 make_tok_num(tline, globalbits);
3459 continue;
3461 tline = delete_Token(tline);
3462 continue;
3464 } else {
3466 * Complicated case: at least one macro with this name
3467 * exists and takes parameters. We must find the
3468 * parameters in the call, count them, find the SMacro
3469 * that corresponds to that form of the macro call, and
3470 * substitute for the parameters when we expand. What a
3471 * pain.
3473 /*tline = tline->next;
3474 skip_white_(tline); */
3475 do {
3476 t = tline->next;
3477 while (tok_type_(t, TOK_SMAC_END)) {
3478 t->a.mac->in_progress = false;
3479 t->text = NULL;
3480 t = tline->next = delete_Token(t);
3482 tline = t;
3483 } while (tok_type_(tline, TOK_WHITESPACE));
3484 if (!tok_is_(tline, "(")) {
3486 * This macro wasn't called with parameters: ignore
3487 * the call. (Behaviour borrowed from gnu cpp.)
3489 tline = mstart;
3490 m = NULL;
3491 } else {
3492 int paren = 0;
3493 int white = 0;
3494 brackets = 0;
3495 nparam = 0;
3496 sparam = PARAM_DELTA;
3497 params = nasm_malloc(sparam * sizeof(Token *));
3498 params[0] = tline->next;
3499 paramsize = nasm_malloc(sparam * sizeof(int));
3500 paramsize[0] = 0;
3501 while (true) { /* parameter loop */
3503 * For some unusual expansions
3504 * which concatenates function call
3506 t = tline->next;
3507 while (tok_type_(t, TOK_SMAC_END)) {
3508 t->a.mac->in_progress = false;
3509 t->text = NULL;
3510 t = tline->next = delete_Token(t);
3512 tline = t;
3514 if (!tline) {
3515 error(ERR_NONFATAL,
3516 "macro call expects terminating `)'");
3517 break;
3519 if (tline->type == TOK_WHITESPACE
3520 && brackets <= 0) {
3521 if (paramsize[nparam])
3522 white++;
3523 else
3524 params[nparam] = tline->next;
3525 continue; /* parameter loop */
3527 if (tline->type == TOK_OTHER
3528 && tline->text[1] == 0) {
3529 char ch = tline->text[0];
3530 if (ch == ',' && !paren && brackets <= 0) {
3531 if (++nparam >= sparam) {
3532 sparam += PARAM_DELTA;
3533 params = nasm_realloc(params,
3534 sparam *
3535 sizeof(Token
3536 *));
3537 paramsize =
3538 nasm_realloc(paramsize,
3539 sparam *
3540 sizeof(int));
3542 params[nparam] = tline->next;
3543 paramsize[nparam] = 0;
3544 white = 0;
3545 continue; /* parameter loop */
3547 if (ch == '{' &&
3548 (brackets > 0 || (brackets == 0 &&
3549 !paramsize[nparam])))
3551 if (!(brackets++)) {
3552 params[nparam] = tline->next;
3553 continue; /* parameter loop */
3556 if (ch == '}' && brackets > 0)
3557 if (--brackets == 0) {
3558 brackets = -1;
3559 continue; /* parameter loop */
3561 if (ch == '(' && !brackets)
3562 paren++;
3563 if (ch == ')' && brackets <= 0)
3564 if (--paren < 0)
3565 break;
3567 if (brackets < 0) {
3568 brackets = 0;
3569 error(ERR_NONFATAL, "braces do not "
3570 "enclose all of macro parameter");
3572 paramsize[nparam] += white + 1;
3573 white = 0;
3574 } /* parameter loop */
3575 nparam++;
3576 while (m && (m->nparam != nparam ||
3577 mstrcmp(m->name, mname,
3578 m->casesense)))
3579 m = m->next;
3580 if (!m)
3581 error(ERR_WARNING | ERR_WARN_MNP,
3582 "macro `%s' exists, "
3583 "but not taking %d parameters",
3584 mstart->text, nparam);
3587 if (m && m->in_progress)
3588 m = NULL;
3589 if (!m) { /* in progess or didn't find '(' or wrong nparam */
3591 * Design question: should we handle !tline, which
3592 * indicates missing ')' here, or expand those
3593 * macros anyway, which requires the (t) test a few
3594 * lines down?
3596 nasm_free(params);
3597 nasm_free(paramsize);
3598 tline = mstart;
3599 } else {
3601 * Expand the macro: we are placed on the last token of the
3602 * call, so that we can easily split the call from the
3603 * following tokens. We also start by pushing an SMAC_END
3604 * token for the cycle removal.
3606 t = tline;
3607 if (t) {
3608 tline = t->next;
3609 t->next = NULL;
3611 tt = new_Token(tline, TOK_SMAC_END, NULL, 0);
3612 tt->a.mac = m;
3613 m->in_progress = true;
3614 tline = tt;
3615 for (t = m->expansion; t; t = t->next) {
3616 if (t->type >= TOK_SMAC_PARAM) {
3617 Token *pcopy = tline, **ptail = &pcopy;
3618 Token *ttt, *pt;
3619 int i;
3621 ttt = params[t->type - TOK_SMAC_PARAM];
3622 for (i = paramsize[t->type - TOK_SMAC_PARAM];
3623 --i >= 0;) {
3624 pt = *ptail =
3625 new_Token(tline, ttt->type, ttt->text,
3627 ptail = &pt->next;
3628 ttt = ttt->next;
3630 tline = pcopy;
3631 } else if (t->type == TOK_PREPROC_Q) {
3632 tt = new_Token(tline, TOK_ID, mname, 0);
3633 tline = tt;
3634 } else if (t->type == TOK_PREPROC_QQ) {
3635 tt = new_Token(tline, TOK_ID, m->name, 0);
3636 tline = tt;
3637 } else {
3638 tt = new_Token(tline, t->type, t->text, 0);
3639 tline = tt;
3644 * Having done that, get rid of the macro call, and clean
3645 * up the parameters.
3647 nasm_free(params);
3648 nasm_free(paramsize);
3649 free_tlist(mstart);
3650 continue; /* main token loop */
3655 if (tline->type == TOK_SMAC_END) {
3656 tline->a.mac->in_progress = false;
3657 tline = delete_Token(tline);
3658 } else {
3659 t = *tail = tline;
3660 tline = tline->next;
3661 t->a.mac = NULL;
3662 t->next = NULL;
3663 tail = &t->next;
3668 * Now scan the entire line and look for successive TOK_IDs that resulted
3669 * after expansion (they can't be produced by tokenize()). The successive
3670 * TOK_IDs should be concatenated.
3671 * Also we look for %+ tokens and concatenate the tokens before and after
3672 * them (without white spaces in between).
3674 t = thead;
3675 rescan = 0;
3676 while (t) {
3677 while (t && t->type != TOK_ID && t->type != TOK_PREPROC_ID)
3678 t = t->next;
3679 if (!t || !t->next)
3680 break;
3681 if (t->next->type == TOK_ID ||
3682 t->next->type == TOK_PREPROC_ID ||
3683 t->next->type == TOK_NUMBER) {
3684 char *p = nasm_strcat(t->text, t->next->text);
3685 nasm_free(t->text);
3686 t->next = delete_Token(t->next);
3687 t->text = p;
3688 rescan = 1;
3689 } else if (t->next->type == TOK_WHITESPACE && t->next->next &&
3690 t->next->next->type == TOK_PREPROC_ID &&
3691 strcmp(t->next->next->text, "%+") == 0) {
3692 /* free the next whitespace, the %+ token and next whitespace */
3693 int i;
3694 for (i = 1; i <= 3; i++) {
3695 if (!t->next
3696 || (i != 2 && t->next->type != TOK_WHITESPACE))
3697 break;
3698 t->next = delete_Token(t->next);
3699 } /* endfor */
3700 } else
3701 t = t->next;
3703 /* If we concatenaded something, re-scan the line for macros */
3704 if (rescan) {
3705 tline = thead;
3706 goto again;
3709 if (org_tline) {
3710 if (thead) {
3711 *org_tline = *thead;
3712 /* since we just gave text to org_line, don't free it */
3713 thead->text = NULL;
3714 delete_Token(thead);
3715 } else {
3716 /* the expression expanded to empty line;
3717 we can't return NULL for some reasons
3718 we just set the line to a single WHITESPACE token. */
3719 memset(org_tline, 0, sizeof(*org_tline));
3720 org_tline->text = NULL;
3721 org_tline->type = TOK_WHITESPACE;
3723 thead = org_tline;
3726 return thead;
3730 * Similar to expand_smacro but used exclusively with macro identifiers
3731 * right before they are fetched in. The reason is that there can be
3732 * identifiers consisting of several subparts. We consider that if there
3733 * are more than one element forming the name, user wants a expansion,
3734 * otherwise it will be left as-is. Example:
3736 * %define %$abc cde
3738 * the identifier %$abc will be left as-is so that the handler for %define
3739 * will suck it and define the corresponding value. Other case:
3741 * %define _%$abc cde
3743 * In this case user wants name to be expanded *before* %define starts
3744 * working, so we'll expand %$abc into something (if it has a value;
3745 * otherwise it will be left as-is) then concatenate all successive
3746 * PP_IDs into one.
3748 static Token *expand_id(Token * tline)
3750 Token *cur, *oldnext = NULL;
3752 if (!tline || !tline->next)
3753 return tline;
3755 cur = tline;
3756 while (cur->next &&
3757 (cur->next->type == TOK_ID ||
3758 cur->next->type == TOK_PREPROC_ID
3759 || cur->next->type == TOK_NUMBER))
3760 cur = cur->next;
3762 /* If identifier consists of just one token, don't expand */
3763 if (cur == tline)
3764 return tline;
3766 if (cur) {
3767 oldnext = cur->next; /* Detach the tail past identifier */
3768 cur->next = NULL; /* so that expand_smacro stops here */
3771 tline = expand_smacro(tline);
3773 if (cur) {
3774 /* expand_smacro possibly changhed tline; re-scan for EOL */
3775 cur = tline;
3776 while (cur && cur->next)
3777 cur = cur->next;
3778 if (cur)
3779 cur->next = oldnext;
3782 return tline;
3786 * Determine whether the given line constitutes a multi-line macro
3787 * call, and return the MMacro structure called if so. Doesn't have
3788 * to check for an initial label - that's taken care of in
3789 * expand_mmacro - but must check numbers of parameters. Guaranteed
3790 * to be called with tline->type == TOK_ID, so the putative macro
3791 * name is easy to find.
3793 static MMacro *is_mmacro(Token * tline, Token *** params_array)
3795 MMacro *head, *m;
3796 Token **params;
3797 int nparam;
3799 head = (MMacro *) hash_findix(&mmacros, tline->text);
3802 * Efficiency: first we see if any macro exists with the given
3803 * name. If not, we can return NULL immediately. _Then_ we
3804 * count the parameters, and then we look further along the
3805 * list if necessary to find the proper MMacro.
3807 for (m = head; m; m = m->next)
3808 if (!mstrcmp(m->name, tline->text, m->casesense))
3809 break;
3810 if (!m)
3811 return NULL;
3814 * OK, we have a potential macro. Count and demarcate the
3815 * parameters.
3817 count_mmac_params(tline->next, &nparam, &params);
3820 * So we know how many parameters we've got. Find the MMacro
3821 * structure that handles this number.
3823 while (m) {
3824 if (m->nparam_min <= nparam
3825 && (m->plus || nparam <= m->nparam_max)) {
3827 * This one is right. Just check if cycle removal
3828 * prohibits us using it before we actually celebrate...
3830 if (m->in_progress) {
3831 #if 0
3832 error(ERR_NONFATAL,
3833 "self-reference in multi-line macro `%s'", m->name);
3834 #endif
3835 nasm_free(params);
3836 return NULL;
3839 * It's right, and we can use it. Add its default
3840 * parameters to the end of our list if necessary.
3842 if (m->defaults && nparam < m->nparam_min + m->ndefs) {
3843 params =
3844 nasm_realloc(params,
3845 ((m->nparam_min + m->ndefs +
3846 1) * sizeof(*params)));
3847 while (nparam < m->nparam_min + m->ndefs) {
3848 params[nparam] = m->defaults[nparam - m->nparam_min];
3849 nparam++;
3853 * If we've gone over the maximum parameter count (and
3854 * we're in Plus mode), ignore parameters beyond
3855 * nparam_max.
3857 if (m->plus && nparam > m->nparam_max)
3858 nparam = m->nparam_max;
3860 * Then terminate the parameter list, and leave.
3862 if (!params) { /* need this special case */
3863 params = nasm_malloc(sizeof(*params));
3864 nparam = 0;
3866 params[nparam] = NULL;
3867 *params_array = params;
3868 return m;
3871 * This one wasn't right: look for the next one with the
3872 * same name.
3874 for (m = m->next; m; m = m->next)
3875 if (!mstrcmp(m->name, tline->text, m->casesense))
3876 break;
3880 * After all that, we didn't find one with the right number of
3881 * parameters. Issue a warning, and fail to expand the macro.
3883 error(ERR_WARNING | ERR_WARN_MNP,
3884 "macro `%s' exists, but not taking %d parameters",
3885 tline->text, nparam);
3886 nasm_free(params);
3887 return NULL;
3891 * Expand the multi-line macro call made by the given line, if
3892 * there is one to be expanded. If there is, push the expansion on
3893 * istk->expansion and return 1. Otherwise return 0.
3895 static int expand_mmacro(Token * tline)
3897 Token *startline = tline;
3898 Token *label = NULL;
3899 int dont_prepend = 0;
3900 Token **params, *t, *mtok, *tt;
3901 MMacro *m;
3902 Line *l, *ll;
3903 int i, nparam, *paramlen;
3904 const char *mname;
3906 t = tline;
3907 skip_white_(t);
3908 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
3909 if (!tok_type_(t, TOK_ID) && !tok_type_(t, TOK_PREPROC_ID))
3910 return 0;
3911 mtok = t;
3912 m = is_mmacro(t, &params);
3913 if (m) {
3914 mname = t->text;
3915 } else {
3916 Token *last;
3918 * We have an id which isn't a macro call. We'll assume
3919 * it might be a label; we'll also check to see if a
3920 * colon follows it. Then, if there's another id after
3921 * that lot, we'll check it again for macro-hood.
3923 label = last = t;
3924 t = t->next;
3925 if (tok_type_(t, TOK_WHITESPACE))
3926 last = t, t = t->next;
3927 if (tok_is_(t, ":")) {
3928 dont_prepend = 1;
3929 last = t, t = t->next;
3930 if (tok_type_(t, TOK_WHITESPACE))
3931 last = t, t = t->next;
3933 if (!tok_type_(t, TOK_ID) || (m = is_mmacro(t, &params)) == NULL)
3934 return 0;
3935 last->next = NULL;
3936 mname = t->text;
3937 tline = t;
3941 * Fix up the parameters: this involves stripping leading and
3942 * trailing whitespace, then stripping braces if they are
3943 * present.
3945 for (nparam = 0; params[nparam]; nparam++) ;
3946 paramlen = nparam ? nasm_malloc(nparam * sizeof(*paramlen)) : NULL;
3948 for (i = 0; params[i]; i++) {
3949 int brace = false;
3950 int comma = (!m->plus || i < nparam - 1);
3952 t = params[i];
3953 skip_white_(t);
3954 if (tok_is_(t, "{"))
3955 t = t->next, brace = true, comma = false;
3956 params[i] = t;
3957 paramlen[i] = 0;
3958 while (t) {
3959 if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
3960 break; /* ... because we have hit a comma */
3961 if (comma && t->type == TOK_WHITESPACE
3962 && tok_is_(t->next, ","))
3963 break; /* ... or a space then a comma */
3964 if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
3965 break; /* ... or a brace */
3966 t = t->next;
3967 paramlen[i]++;
3972 * OK, we have a MMacro structure together with a set of
3973 * parameters. We must now go through the expansion and push
3974 * copies of each Line on to istk->expansion. Substitution of
3975 * parameter tokens and macro-local tokens doesn't get done
3976 * until the single-line macro substitution process; this is
3977 * because delaying them allows us to change the semantics
3978 * later through %rotate.
3980 * First, push an end marker on to istk->expansion, mark this
3981 * macro as in progress, and set up its invocation-specific
3982 * variables.
3984 ll = nasm_malloc(sizeof(Line));
3985 ll->next = istk->expansion;
3986 ll->finishes = m;
3987 ll->first = NULL;
3988 istk->expansion = ll;
3990 m->in_progress = true;
3991 m->params = params;
3992 m->iline = tline;
3993 m->nparam = nparam;
3994 m->rotate = 0;
3995 m->paramlen = paramlen;
3996 m->unique = unique++;
3997 m->lineno = 0;
3999 m->next_active = istk->mstk;
4000 istk->mstk = m;
4002 for (l = m->expansion; l; l = l->next) {
4003 Token **tail;
4005 ll = nasm_malloc(sizeof(Line));
4006 ll->finishes = NULL;
4007 ll->next = istk->expansion;
4008 istk->expansion = ll;
4009 tail = &ll->first;
4011 for (t = l->first; t; t = t->next) {
4012 Token *x = t;
4013 switch (t->type) {
4014 case TOK_PREPROC_Q:
4015 tt = *tail = new_Token(NULL, TOK_ID, mname, 0);
4016 break;
4017 case TOK_PREPROC_QQ:
4018 tt = *tail = new_Token(NULL, TOK_ID, m->name, 0);
4019 break;
4020 case TOK_PREPROC_ID:
4021 if (t->text[1] == '0' && t->text[2] == '0') {
4022 dont_prepend = -1;
4023 x = label;
4024 if (!x)
4025 continue;
4027 /* fall through */
4028 default:
4029 tt = *tail = new_Token(NULL, x->type, x->text, 0);
4030 break;
4032 tail = &tt->next;
4034 *tail = NULL;
4038 * If we had a label, push it on as the first line of
4039 * the macro expansion.
4041 if (label) {
4042 if (dont_prepend < 0)
4043 free_tlist(startline);
4044 else {
4045 ll = nasm_malloc(sizeof(Line));
4046 ll->finishes = NULL;
4047 ll->next = istk->expansion;
4048 istk->expansion = ll;
4049 ll->first = startline;
4050 if (!dont_prepend) {
4051 while (label->next)
4052 label = label->next;
4053 label->next = tt = new_Token(NULL, TOK_OTHER, ":", 0);
4058 list->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
4060 return 1;
4064 * Since preprocessor always operate only on the line that didn't
4065 * arrived yet, we should always use ERR_OFFBY1. Also since user
4066 * won't want to see same error twice (preprocessing is done once
4067 * per pass) we will want to show errors only during pass one.
4069 static void error(int severity, const char *fmt, ...)
4071 va_list arg;
4072 char buff[1024];
4074 /* If we're in a dead branch of IF or something like it, ignore the error */
4075 if (istk && istk->conds && !emitting(istk->conds->state))
4076 return;
4078 va_start(arg, fmt);
4079 vsnprintf(buff, sizeof(buff), fmt, arg);
4080 va_end(arg);
4082 if (istk && istk->mstk && istk->mstk->name)
4083 _error(severity | ERR_PASS1, "(%s:%d) %s", istk->mstk->name,
4084 istk->mstk->lineno, buff);
4085 else
4086 _error(severity | ERR_PASS1, "%s", buff);
4089 static void
4090 pp_reset(char *file, int apass, efunc errfunc, evalfunc eval,
4091 ListGen * listgen, StrList **deplist)
4093 _error = errfunc;
4094 cstk = NULL;
4095 istk = nasm_malloc(sizeof(Include));
4096 istk->next = NULL;
4097 istk->conds = NULL;
4098 istk->expansion = NULL;
4099 istk->mstk = NULL;
4100 istk->fp = fopen(file, "r");
4101 istk->fname = NULL;
4102 src_set_fname(nasm_strdup(file));
4103 src_set_linnum(0);
4104 istk->lineinc = 1;
4105 if (!istk->fp)
4106 error(ERR_FATAL | ERR_NOFILE, "unable to open input file `%s'",
4107 file);
4108 defining = NULL;
4109 nested_mac_count = 0;
4110 nested_rep_count = 0;
4111 init_macros();
4112 unique = 0;
4113 if (tasm_compatible_mode) {
4114 stdmacpos = nasm_stdmac;
4115 } else {
4116 stdmacpos = nasm_stdmac_after_tasm;
4118 any_extrastdmac = extrastdmac && *extrastdmac;
4119 do_predef = true;
4120 list = listgen;
4121 evaluate = eval;
4122 pass = apass;
4123 dephead = deptail = deplist;
4124 if (deplist) {
4125 StrList *sl = nasm_malloc(strlen(file)+1+sizeof sl->next);
4126 sl->next = NULL;
4127 strcpy(sl->str, file);
4128 *deptail = sl;
4129 deptail = &sl->next;
4133 static char *pp_getline(void)
4135 char *line;
4136 Token *tline;
4138 while (1) {
4140 * Fetch a tokenized line, either from the macro-expansion
4141 * buffer or from the input file.
4143 tline = NULL;
4144 while (istk->expansion && istk->expansion->finishes) {
4145 Line *l = istk->expansion;
4146 if (!l->finishes->name && l->finishes->in_progress > 1) {
4147 Line *ll;
4150 * This is a macro-end marker for a macro with no
4151 * name, which means it's not really a macro at all
4152 * but a %rep block, and the `in_progress' field is
4153 * more than 1, meaning that we still need to
4154 * repeat. (1 means the natural last repetition; 0
4155 * means termination by %exitrep.) We have
4156 * therefore expanded up to the %endrep, and must
4157 * push the whole block on to the expansion buffer
4158 * again. We don't bother to remove the macro-end
4159 * marker: we'd only have to generate another one
4160 * if we did.
4162 l->finishes->in_progress--;
4163 for (l = l->finishes->expansion; l; l = l->next) {
4164 Token *t, *tt, **tail;
4166 ll = nasm_malloc(sizeof(Line));
4167 ll->next = istk->expansion;
4168 ll->finishes = NULL;
4169 ll->first = NULL;
4170 tail = &ll->first;
4172 for (t = l->first; t; t = t->next) {
4173 if (t->text || t->type == TOK_WHITESPACE) {
4174 tt = *tail =
4175 new_Token(NULL, t->type, t->text, 0);
4176 tail = &tt->next;
4180 istk->expansion = ll;
4182 } else {
4184 * Check whether a `%rep' was started and not ended
4185 * within this macro expansion. This can happen and
4186 * should be detected. It's a fatal error because
4187 * I'm too confused to work out how to recover
4188 * sensibly from it.
4190 if (defining) {
4191 if (defining->name)
4192 error(ERR_PANIC,
4193 "defining with name in expansion");
4194 else if (istk->mstk->name)
4195 error(ERR_FATAL,
4196 "`%%rep' without `%%endrep' within"
4197 " expansion of macro `%s'",
4198 istk->mstk->name);
4202 * FIXME: investigate the relationship at this point between
4203 * istk->mstk and l->finishes
4206 MMacro *m = istk->mstk;
4207 istk->mstk = m->next_active;
4208 if (m->name) {
4210 * This was a real macro call, not a %rep, and
4211 * therefore the parameter information needs to
4212 * be freed.
4214 nasm_free(m->params);
4215 free_tlist(m->iline);
4216 nasm_free(m->paramlen);
4217 l->finishes->in_progress = false;
4218 } else
4219 free_mmacro(m);
4221 istk->expansion = l->next;
4222 nasm_free(l);
4223 list->downlevel(LIST_MACRO);
4226 while (1) { /* until we get a line we can use */
4228 if (istk->expansion) { /* from a macro expansion */
4229 char *p;
4230 Line *l = istk->expansion;
4231 if (istk->mstk)
4232 istk->mstk->lineno++;
4233 tline = l->first;
4234 istk->expansion = l->next;
4235 nasm_free(l);
4236 p = detoken(tline, false);
4237 list->line(LIST_MACRO, p);
4238 nasm_free(p);
4239 break;
4241 line = read_line();
4242 if (line) { /* from the current input file */
4243 line = prepreproc(line);
4244 tline = tokenize(line);
4245 nasm_free(line);
4246 break;
4249 * The current file has ended; work down the istk
4252 Include *i = istk;
4253 fclose(i->fp);
4254 if (i->conds)
4255 error(ERR_FATAL,
4256 "expected `%%endif' before end of file");
4257 /* only set line and file name if there's a next node */
4258 if (i->next) {
4259 src_set_linnum(i->lineno);
4260 nasm_free(src_set_fname(i->fname));
4262 istk = i->next;
4263 list->downlevel(LIST_INCLUDE);
4264 nasm_free(i);
4265 if (!istk)
4266 return NULL;
4271 * We must expand MMacro parameters and MMacro-local labels
4272 * _before_ we plunge into directive processing, to cope
4273 * with things like `%define something %1' such as STRUC
4274 * uses. Unless we're _defining_ a MMacro, in which case
4275 * those tokens should be left alone to go into the
4276 * definition; and unless we're in a non-emitting
4277 * condition, in which case we don't want to meddle with
4278 * anything.
4280 if (!defining && !(istk->conds && !emitting(istk->conds->state))
4281 && !(istk->mstk && !istk->mstk->in_progress))
4282 tline = expand_mmac_params(tline);
4285 * Check the line to see if it's a preprocessor directive.
4287 if (do_directive(tline) == DIRECTIVE_FOUND) {
4288 continue;
4289 } else if (defining) {
4291 * We're defining a multi-line macro. We emit nothing
4292 * at all, and just
4293 * shove the tokenized line on to the macro definition.
4295 Line *l = nasm_malloc(sizeof(Line));
4296 l->next = defining->expansion;
4297 l->first = tline;
4298 l->finishes = NULL;
4299 defining->expansion = l;
4300 continue;
4301 } else if (istk->conds && !emitting(istk->conds->state)) {
4303 * We're in a non-emitting branch of a condition block.
4304 * Emit nothing at all, not even a blank line: when we
4305 * emerge from the condition we'll give a line-number
4306 * directive so we keep our place correctly.
4308 free_tlist(tline);
4309 continue;
4310 } else if (istk->mstk && !istk->mstk->in_progress) {
4312 * We're in a %rep block which has been terminated, so
4313 * we're walking through to the %endrep without
4314 * emitting anything. Emit nothing at all, not even a
4315 * blank line: when we emerge from the %rep block we'll
4316 * give a line-number directive so we keep our place
4317 * correctly.
4319 free_tlist(tline);
4320 continue;
4321 } else {
4322 tline = expand_smacro(tline);
4323 if (!expand_mmacro(tline)) {
4325 * De-tokenize the line again, and emit it.
4327 line = detoken(tline, true);
4328 free_tlist(tline);
4329 break;
4330 } else {
4331 continue; /* expand_mmacro calls free_tlist */
4336 return line;
4339 static void pp_cleanup(int pass)
4341 if (defining) {
4342 error(ERR_NONFATAL, "end of file while still defining macro `%s'",
4343 defining->name);
4344 free_mmacro(defining);
4346 while (cstk)
4347 ctx_pop();
4348 free_macros();
4349 while (istk) {
4350 Include *i = istk;
4351 istk = istk->next;
4352 fclose(i->fp);
4353 nasm_free(i->fname);
4354 nasm_free(i);
4356 while (cstk)
4357 ctx_pop();
4358 nasm_free(src_set_fname(NULL));
4359 if (pass == 0) {
4360 IncPath *i;
4361 free_llist(predef);
4362 delete_Blocks();
4363 while ((i = ipath)) {
4364 ipath = i->next;
4365 if (i->path)
4366 nasm_free(i->path);
4367 nasm_free(i);
4372 void pp_include_path(char *path)
4374 IncPath *i;
4376 i = nasm_malloc(sizeof(IncPath));
4377 i->path = path ? nasm_strdup(path) : NULL;
4378 i->next = NULL;
4380 if (ipath != NULL) {
4381 IncPath *j = ipath;
4382 while (j->next != NULL)
4383 j = j->next;
4384 j->next = i;
4385 } else {
4386 ipath = i;
4390 void pp_pre_include(char *fname)
4392 Token *inc, *space, *name;
4393 Line *l;
4395 name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
4396 space = new_Token(name, TOK_WHITESPACE, NULL, 0);
4397 inc = new_Token(space, TOK_PREPROC_ID, "%include", 0);
4399 l = nasm_malloc(sizeof(Line));
4400 l->next = predef;
4401 l->first = inc;
4402 l->finishes = NULL;
4403 predef = l;
4406 void pp_pre_define(char *definition)
4408 Token *def, *space;
4409 Line *l;
4410 char *equals;
4412 equals = strchr(definition, '=');
4413 space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4414 def = new_Token(space, TOK_PREPROC_ID, "%define", 0);
4415 if (equals)
4416 *equals = ' ';
4417 space->next = tokenize(definition);
4418 if (equals)
4419 *equals = '=';
4421 l = nasm_malloc(sizeof(Line));
4422 l->next = predef;
4423 l->first = def;
4424 l->finishes = NULL;
4425 predef = l;
4428 void pp_pre_undefine(char *definition)
4430 Token *def, *space;
4431 Line *l;
4433 space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4434 def = new_Token(space, TOK_PREPROC_ID, "%undef", 0);
4435 space->next = tokenize(definition);
4437 l = nasm_malloc(sizeof(Line));
4438 l->next = predef;
4439 l->first = def;
4440 l->finishes = NULL;
4441 predef = l;
4445 * Added by Keith Kanios:
4447 * This function is used to assist with "runtime" preprocessor
4448 * directives. (e.g. pp_runtime("%define __BITS__ 64");)
4450 * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
4451 * PASS A VALID STRING TO THIS FUNCTION!!!!!
4454 void pp_runtime(char *definition)
4456 Token *def;
4458 def = tokenize(definition);
4459 if(do_directive(def) == NO_DIRECTIVE_FOUND)
4460 free_tlist(def);
4464 void pp_extra_stdmac(const macros_t *macros)
4466 extrastdmac = macros;
4469 static void make_tok_num(Token * tok, int64_t val)
4471 char numbuf[20];
4472 snprintf(numbuf, sizeof(numbuf), "%"PRId64"", val);
4473 tok->text = nasm_strdup(numbuf);
4474 tok->type = TOK_NUMBER;
4477 Preproc nasmpp = {
4478 pp_reset,
4479 pp_getline,
4480 pp_cleanup