quote: use nasm_assert() instead of plain assert()
[nasm.git] / preproc.c
blobbac5a77a3dbf1b0222263b1a7e86669cfe65d5a3
1 /* ----------------------------------------------------------------------- *
2 *
3 * Copyright 1996-2009 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
9 * conditions are met:
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * preproc.c macro preprocessor for the Netwide Assembler
38 /* Typical flow of text through preproc
40 * pp_getline gets tokenized lines, either
42 * from a macro expansion
44 * or
45 * {
46 * read_line gets raw text from stdmacpos, or predef, or current input file
47 * tokenize converts to tokens
48 * }
50 * expand_mmac_params is used to expand %1 etc., unless a macro is being
51 * defined or a false conditional is being processed
52 * (%0, %1, %+1, %-1, %%foo
54 * do_directive checks for directives
56 * expand_smacro is used to expand single line macros
58 * expand_mmacro is used to expand multi-line macros
60 * detoken is used to convert the line back to text
63 #include "compiler.h"
65 #include <stdio.h>
66 #include <stdarg.h>
67 #include <stdlib.h>
68 #include <stddef.h>
69 #include <string.h>
70 #include <ctype.h>
71 #include <limits.h>
72 #include <inttypes.h>
74 #include "nasm.h"
75 #include "nasmlib.h"
76 #include "preproc.h"
77 #include "hashtbl.h"
78 #include "quote.h"
79 #include "stdscan.h"
80 #include "tokens.h"
81 #include "tables.h"
83 typedef struct SMacro SMacro;
84 typedef struct MMacro MMacro;
85 typedef struct MMacroInvocation MMacroInvocation;
86 typedef struct Context Context;
87 typedef struct Token Token;
88 typedef struct Blocks Blocks;
89 typedef struct Line Line;
90 typedef struct Include Include;
91 typedef struct Cond Cond;
92 typedef struct IncPath IncPath;
95 * Note on the storage of both SMacro and MMacros: the hash table
96 * indexes them case-insensitively, and we then have to go through a
97 * linked list of potential case aliases (and, for MMacros, parameter
98 * ranges); this is to preserve the matching semantics of the earlier
99 * code. If the number of case aliases for a specific macro is a
100 * performance issue, you may want to reconsider your coding style.
104 * Store the definition of a single-line macro.
106 struct SMacro {
107 SMacro *next;
108 char *name;
109 bool casesense;
110 bool in_progress;
111 unsigned int nparam;
112 Token *expansion;
116 * Store the definition of a multi-line macro. This is also used to
117 * store the interiors of `%rep...%endrep' blocks, which are
118 * effectively self-re-invoking multi-line macros which simply
119 * don't have a name or bother to appear in the hash tables. %rep
120 * blocks are signified by having a NULL `name' field.
122 * In a MMacro describing a `%rep' block, the `in_progress' field
123 * isn't merely boolean, but gives the number of repeats left to
124 * run.
126 * The `next' field is used for storing MMacros in hash tables; the
127 * `next_active' field is for stacking them on istk entries.
129 * When a MMacro is being expanded, `params', `iline', `nparam',
130 * `paramlen', `rotate' and `unique' are local to the invocation.
132 struct MMacro {
133 MMacro *next;
134 MMacroInvocation *prev; /* previous invocation */
135 char *name;
136 int nparam_min, nparam_max;
137 bool casesense;
138 bool plus; /* is the last parameter greedy? */
139 bool nolist; /* is this macro listing-inhibited? */
140 int64_t in_progress; /* is this macro currently being expanded? */
141 int32_t max_depth; /* maximum number of recursive expansions allowed */
142 Token *dlist; /* All defaults as one list */
143 Token **defaults; /* Parameter default pointers */
144 int ndefs; /* number of default parameters */
145 Line *expansion;
147 MMacro *next_active;
148 MMacro *rep_nest; /* used for nesting %rep */
149 Token **params; /* actual parameters */
150 Token *iline; /* invocation line */
151 unsigned int nparam, rotate;
152 int *paramlen;
153 uint64_t unique;
154 int lineno; /* Current line number on expansion */
158 /* Store the definition of a multi-line macro, as defined in a
159 * previous recursive macro expansion.
161 struct MMacroInvocation {
162 MMacroInvocation *prev; /* previous invocation */
163 Token **params; /* actual parameters */
164 Token *iline; /* invocation line */
165 unsigned int nparam, rotate;
166 int *paramlen;
167 uint64_t unique;
172 * The context stack is composed of a linked list of these.
174 struct Context {
175 Context *next;
176 char *name;
177 struct hash_table localmac;
178 uint32_t number;
182 * This is the internal form which we break input lines up into.
183 * Typically stored in linked lists.
185 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
186 * necessarily used as-is, but is intended to denote the number of
187 * the substituted parameter. So in the definition
189 * %define a(x,y) ( (x) & ~(y) )
191 * the token representing `x' will have its type changed to
192 * TOK_SMAC_PARAM, but the one representing `y' will be
193 * TOK_SMAC_PARAM+1.
195 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
196 * which doesn't need quotes around it. Used in the pre-include
197 * mechanism as an alternative to trying to find a sensible type of
198 * quote to use on the filename we were passed.
200 enum pp_token_type {
201 TOK_NONE = 0, TOK_WHITESPACE, TOK_COMMENT, TOK_ID,
202 TOK_PREPROC_ID, TOK_STRING,
203 TOK_NUMBER, TOK_FLOAT, TOK_SMAC_END, TOK_OTHER,
204 TOK_INTERNAL_STRING,
205 TOK_PREPROC_Q, TOK_PREPROC_QQ,
206 TOK_PASTE, /* %+ */
207 TOK_INDIRECT, /* %[...] */
208 TOK_SMAC_PARAM, /* MUST BE LAST IN THE LIST!!! */
209 TOK_MAX = INT_MAX /* Keep compiler from reducing the range */
212 struct Token {
213 Token *next;
214 char *text;
215 union {
216 SMacro *mac; /* associated macro for TOK_SMAC_END */
217 size_t len; /* scratch length field */
218 } a; /* Auxiliary data */
219 enum pp_token_type type;
223 * Multi-line macro definitions are stored as a linked list of
224 * these, which is essentially a container to allow several linked
225 * lists of Tokens.
227 * Note that in this module, linked lists are treated as stacks
228 * wherever possible. For this reason, Lines are _pushed_ on to the
229 * `expansion' field in MMacro structures, so that the linked list,
230 * if walked, would give the macro lines in reverse order; this
231 * means that we can walk the list when expanding a macro, and thus
232 * push the lines on to the `expansion' field in _istk_ in reverse
233 * order (so that when popped back off they are in the right
234 * order). It may seem cockeyed, and it relies on my design having
235 * an even number of steps in, but it works...
237 * Some of these structures, rather than being actual lines, are
238 * markers delimiting the end of the expansion of a given macro.
239 * This is for use in the cycle-tracking and %rep-handling code.
240 * Such structures have `finishes' non-NULL, and `first' NULL. All
241 * others have `finishes' NULL, but `first' may still be NULL if
242 * the line is blank.
244 struct Line {
245 Line *next;
246 MMacro *finishes;
247 Token *first;
251 * To handle an arbitrary level of file inclusion, we maintain a
252 * stack (ie linked list) of these things.
254 struct Include {
255 Include *next;
256 FILE *fp;
257 Cond *conds;
258 Line *expansion;
259 char *fname;
260 int lineno, lineinc;
261 MMacro *mstk; /* stack of active macros/reps */
265 * Include search path. This is simply a list of strings which get
266 * prepended, in turn, to the name of an include file, in an
267 * attempt to find the file if it's not in the current directory.
269 struct IncPath {
270 IncPath *next;
271 char *path;
275 * Conditional assembly: we maintain a separate stack of these for
276 * each level of file inclusion. (The only reason we keep the
277 * stacks separate is to ensure that a stray `%endif' in a file
278 * included from within the true branch of a `%if' won't terminate
279 * it and cause confusion: instead, rightly, it'll cause an error.)
281 struct Cond {
282 Cond *next;
283 int state;
285 enum {
287 * These states are for use just after %if or %elif: IF_TRUE
288 * means the condition has evaluated to truth so we are
289 * currently emitting, whereas IF_FALSE means we are not
290 * currently emitting but will start doing so if a %else comes
291 * up. In these states, all directives are admissible: %elif,
292 * %else and %endif. (And of course %if.)
294 COND_IF_TRUE, COND_IF_FALSE,
296 * These states come up after a %else: ELSE_TRUE means we're
297 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
298 * any %elif or %else will cause an error.
300 COND_ELSE_TRUE, COND_ELSE_FALSE,
302 * These states mean that we're not emitting now, and also that
303 * nothing until %endif will be emitted at all. COND_DONE is
304 * used when we've had our moment of emission
305 * and have now started seeing %elifs. COND_NEVER is used when
306 * the condition construct in question is contained within a
307 * non-emitting branch of a larger condition construct,
308 * or if there is an error.
310 COND_DONE, COND_NEVER
312 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
315 * These defines are used as the possible return values for do_directive
317 #define NO_DIRECTIVE_FOUND 0
318 #define DIRECTIVE_FOUND 1
321 * This define sets the upper limit for smacro and recursive mmacro
322 * expansions
324 #define DEADMAN_LIMIT (1 << 20)
327 * Condition codes. Note that we use c_ prefix not C_ because C_ is
328 * used in nasm.h for the "real" condition codes. At _this_ level,
329 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
330 * ones, so we need a different enum...
332 static const char * const conditions[] = {
333 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
334 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
335 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
337 enum pp_conds {
338 c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE,
339 c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO,
340 c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_RCXZ, c_S, c_Z,
341 c_none = -1
343 static const enum pp_conds inverse_ccs[] = {
344 c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE,
345 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,
346 c_Z, c_NO, c_NP, c_PO, c_PE, -1, c_NS, c_NZ
350 * Directive names.
352 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
353 static int is_condition(enum preproc_token arg)
355 return PP_IS_COND(arg) || (arg == PP_ELSE) || (arg == PP_ENDIF);
358 /* For TASM compatibility we need to be able to recognise TASM compatible
359 * conditional compilation directives. Using the NASM pre-processor does
360 * not work, so we look for them specifically from the following list and
361 * then jam in the equivalent NASM directive into the input stream.
364 enum {
365 TM_ARG, TM_ELIF, TM_ELSE, TM_ENDIF, TM_IF, TM_IFDEF, TM_IFDIFI,
366 TM_IFNDEF, TM_INCLUDE, TM_LOCAL
369 static const char * const tasm_directives[] = {
370 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
371 "ifndef", "include", "local"
374 static int StackSize = 4;
375 static char *StackPointer = "ebp";
376 static int ArgOffset = 8;
377 static int LocalOffset = 0;
379 static Context *cstk;
380 static Include *istk;
381 static IncPath *ipath = NULL;
383 static efunc _error; /* Pointer to client-provided error reporting function */
384 static evalfunc evaluate;
386 static int pass; /* HACK: pass 0 = generate dependencies only */
387 static StrList **dephead, **deptail; /* Dependency list */
389 static uint64_t unique; /* unique identifier numbers */
391 static Line *predef = NULL;
392 static bool do_predef;
394 static ListGen *list;
397 * The current set of multi-line macros we have defined.
399 static struct hash_table mmacros;
402 * The current set of single-line macros we have defined.
404 static struct hash_table smacros;
407 * The multi-line macro we are currently defining, or the %rep
408 * block we are currently reading, if any.
410 static MMacro *defining;
412 static uint64_t nested_mac_count;
413 static uint64_t nested_rep_count;
416 * The number of macro parameters to allocate space for at a time.
418 #define PARAM_DELTA 16
421 * The standard macro set: defined in macros.c in the array nasm_stdmac.
422 * This gives our position in the macro set, when we're processing it.
424 static macros_t *stdmacpos;
427 * The extra standard macros that come from the object format, if
428 * any.
430 static macros_t *extrastdmac = NULL;
431 static bool any_extrastdmac;
434 * Tokens are allocated in blocks to improve speed
436 #define TOKEN_BLOCKSIZE 4096
437 static Token *freeTokens = NULL;
438 struct Blocks {
439 Blocks *next;
440 void *chunk;
443 static Blocks blocks = { NULL, NULL };
446 * Forward declarations.
448 static Token *expand_mmac_params(Token * tline);
449 static Token *expand_smacro(Token * tline);
450 static Token *expand_id(Token * tline);
451 static Context *get_ctx(const char *name, const char **namep,
452 bool all_contexts);
453 static void make_tok_num(Token * tok, int64_t val);
454 static void error(int severity, const char *fmt, ...);
455 static void error_precond(int severity, const char *fmt, ...);
456 static void *new_Block(size_t size);
457 static void delete_Blocks(void);
458 static Token *new_Token(Token * next, enum pp_token_type type,
459 const char *text, int txtlen);
460 static Token *delete_Token(Token * t);
463 * Macros for safe checking of token pointers, avoid *(NULL)
465 #define tok_type_(x,t) ((x) && (x)->type == (t))
466 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
467 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
468 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
470 /* Handle TASM specific directives, which do not contain a % in
471 * front of them. We do it here because I could not find any other
472 * place to do it for the moment, and it is a hack (ideally it would
473 * be nice to be able to use the NASM pre-processor to do it).
475 static char *check_tasm_directive(char *line)
477 int32_t i, j, k, m, len;
478 char *p = line, *oldline, oldchar;
480 /* Skip whitespace */
481 while (nasm_isspace(*p) && *p != 0)
482 p++;
484 /* Binary search for the directive name */
485 i = -1;
486 j = elements(tasm_directives);
487 len = 0;
488 while (!nasm_isspace(p[len]) && p[len] != 0)
489 len++;
490 if (len) {
491 oldchar = p[len];
492 p[len] = 0;
493 while (j - i > 1) {
494 k = (j + i) / 2;
495 m = nasm_stricmp(p, tasm_directives[k]);
496 if (m == 0) {
497 /* We have found a directive, so jam a % in front of it
498 * so that NASM will then recognise it as one if it's own.
500 p[len] = oldchar;
501 len = strlen(p);
502 oldline = line;
503 line = nasm_malloc(len + 2);
504 line[0] = '%';
505 if (k == TM_IFDIFI) {
507 * NASM does not recognise IFDIFI, so we convert
508 * it to %if 0. This is not used in NASM
509 * compatible code, but does need to parse for the
510 * TASM macro package.
512 strcpy(line + 1, "if 0");
513 } else {
514 memcpy(line + 1, p, len + 1);
516 nasm_free(oldline);
517 return line;
518 } else if (m < 0) {
519 j = k;
520 } else
521 i = k;
523 p[len] = oldchar;
525 return line;
529 * The pre-preprocessing stage... This function translates line
530 * number indications as they emerge from GNU cpp (`# lineno "file"
531 * flags') into NASM preprocessor line number indications (`%line
532 * lineno file').
534 static char *prepreproc(char *line)
536 int lineno, fnlen;
537 char *fname, *oldline;
539 if (line[0] == '#' && line[1] == ' ') {
540 oldline = line;
541 fname = oldline + 2;
542 lineno = atoi(fname);
543 fname += strspn(fname, "0123456789 ");
544 if (*fname == '"')
545 fname++;
546 fnlen = strcspn(fname, "\"");
547 line = nasm_malloc(20 + fnlen);
548 snprintf(line, 20 + fnlen, "%%line %d %.*s", lineno, fnlen, fname);
549 nasm_free(oldline);
551 if (tasm_compatible_mode)
552 return check_tasm_directive(line);
553 return line;
557 * Free a linked list of tokens.
559 static void free_tlist(Token * list)
561 while (list) {
562 list = delete_Token(list);
567 * Free a linked list of lines.
569 static void free_llist(Line * list)
571 Line *l;
572 while (list) {
573 l = list;
574 list = list->next;
575 free_tlist(l->first);
576 nasm_free(l);
581 * Free an MMacro
583 static void free_mmacro(MMacro * m)
585 nasm_free(m->name);
586 free_tlist(m->dlist);
587 nasm_free(m->defaults);
588 free_llist(m->expansion);
589 nasm_free(m);
593 * Free all currently defined macros, and free the hash tables
595 static void free_smacro_table(struct hash_table *smt)
597 SMacro *s;
598 const char *key;
599 struct hash_tbl_node *it = NULL;
601 while ((s = hash_iterate(smt, &it, &key)) != NULL) {
602 nasm_free((void *)key);
603 while (s) {
604 SMacro *ns = s->next;
605 nasm_free(s->name);
606 free_tlist(s->expansion);
607 nasm_free(s);
608 s = ns;
611 hash_free(smt);
614 static void free_mmacro_table(struct hash_table *mmt)
616 MMacro *m;
617 const char *key;
618 struct hash_tbl_node *it = NULL;
620 it = NULL;
621 while ((m = hash_iterate(mmt, &it, &key)) != NULL) {
622 nasm_free((void *)key);
623 while (m) {
624 MMacro *nm = m->next;
625 free_mmacro(m);
626 m = nm;
629 hash_free(mmt);
632 static void free_macros(void)
634 free_smacro_table(&smacros);
635 free_mmacro_table(&mmacros);
639 * Initialize the hash tables
641 static void init_macros(void)
643 hash_init(&smacros, HASH_LARGE);
644 hash_init(&mmacros, HASH_LARGE);
648 * Pop the context stack.
650 static void ctx_pop(void)
652 Context *c = cstk;
654 cstk = cstk->next;
655 free_smacro_table(&c->localmac);
656 nasm_free(c->name);
657 nasm_free(c);
661 * Search for a key in the hash index; adding it if necessary
662 * (in which case we initialize the data pointer to NULL.)
664 static void **
665 hash_findi_add(struct hash_table *hash, const char *str)
667 struct hash_insert hi;
668 void **r;
669 char *strx;
671 r = hash_findi(hash, str, &hi);
672 if (r)
673 return r;
675 strx = nasm_strdup(str); /* Use a more efficient allocator here? */
676 return hash_add(&hi, strx, NULL);
680 * Like hash_findi, but returns the data element rather than a pointer
681 * to it. Used only when not adding a new element, hence no third
682 * argument.
684 static void *
685 hash_findix(struct hash_table *hash, const char *str)
687 void **p;
689 p = hash_findi(hash, str, NULL);
690 return p ? *p : NULL;
693 #define BUF_DELTA 512
695 * Read a line from the top file in istk, handling multiple CR/LFs
696 * at the end of the line read, and handling spurious ^Zs. Will
697 * return lines from the standard macro set if this has not already
698 * been done.
700 static char *read_line(void)
702 char *buffer, *p, *q;
703 int bufsize, continued_count;
705 if (stdmacpos) {
706 unsigned char c;
707 const unsigned char *p = stdmacpos;
708 char *ret, *q;
709 size_t len = 0;
710 while ((c = *p++)) {
711 if (c >= 0x80)
712 len += pp_directives_len[c-0x80]+1;
713 else
714 len++;
716 ret = nasm_malloc(len+1);
717 q = ret;
718 while ((c = *stdmacpos++)) {
719 if (c >= 0x80) {
720 memcpy(q, pp_directives[c-0x80], pp_directives_len[c-0x80]);
721 q += pp_directives_len[c-0x80];
722 *q++ = ' ';
723 } else {
724 *q++ = c;
727 stdmacpos = p;
728 *q = '\0';
730 if (!*stdmacpos) {
731 /* This was the last of the standard macro chain... */
732 stdmacpos = NULL;
733 if (any_extrastdmac) {
734 stdmacpos = extrastdmac;
735 any_extrastdmac = false;
736 } else if (do_predef) {
737 Line *pd, *l;
738 Token *head, **tail, *t;
741 * Nasty hack: here we push the contents of
742 * `predef' on to the top-level expansion stack,
743 * since this is the most convenient way to
744 * implement the pre-include and pre-define
745 * features.
747 for (pd = predef; pd; pd = pd->next) {
748 head = NULL;
749 tail = &head;
750 for (t = pd->first; t; t = t->next) {
751 *tail = new_Token(NULL, t->type, t->text, 0);
752 tail = &(*tail)->next;
754 l = nasm_malloc(sizeof(Line));
755 l->next = istk->expansion;
756 l->first = head;
757 l->finishes = NULL;
758 istk->expansion = l;
760 do_predef = false;
763 return ret;
766 bufsize = BUF_DELTA;
767 buffer = nasm_malloc(BUF_DELTA);
768 p = buffer;
769 continued_count = 0;
770 while (1) {
771 q = fgets(p, bufsize - (p - buffer), istk->fp);
772 if (!q)
773 break;
774 p += strlen(p);
775 if (p > buffer && p[-1] == '\n') {
776 /* Convert backslash-CRLF line continuation sequences into
777 nothing at all (for DOS and Windows) */
778 if (((p - 2) > buffer) && (p[-3] == '\\') && (p[-2] == '\r')) {
779 p -= 3;
780 *p = 0;
781 continued_count++;
783 /* Also convert backslash-LF line continuation sequences into
784 nothing at all (for Unix) */
785 else if (((p - 1) > buffer) && (p[-2] == '\\')) {
786 p -= 2;
787 *p = 0;
788 continued_count++;
789 } else {
790 break;
793 if (p - buffer > bufsize - 10) {
794 int32_t offset = p - buffer;
795 bufsize += BUF_DELTA;
796 buffer = nasm_realloc(buffer, bufsize);
797 p = buffer + offset; /* prevent stale-pointer problems */
801 if (!q && p == buffer) {
802 nasm_free(buffer);
803 return NULL;
806 src_set_linnum(src_get_linnum() + istk->lineinc +
807 (continued_count * istk->lineinc));
810 * Play safe: remove CRs as well as LFs, if any of either are
811 * present at the end of the line.
813 while (--p >= buffer && (*p == '\n' || *p == '\r'))
814 *p = '\0';
817 * Handle spurious ^Z, which may be inserted into source files
818 * by some file transfer utilities.
820 buffer[strcspn(buffer, "\032")] = '\0';
822 list->line(LIST_READ, buffer);
824 return buffer;
828 * Tokenize a line of text. This is a very simple process since we
829 * don't need to parse the value out of e.g. numeric tokens: we
830 * simply split one string into many.
832 static Token *tokenize(char *line)
834 char c, *p = line;
835 enum pp_token_type type;
836 Token *list = NULL;
837 Token *t, **tail = &list;
839 while (*line) {
840 p = line;
841 if (*p == '%') {
842 p++;
843 if (*p == '+' && !nasm_isdigit(p[1])) {
844 p++;
845 type = TOK_PASTE;
846 } else if (nasm_isdigit(*p) ||
847 ((*p == '-' || *p == '+') && nasm_isdigit(p[1]))) {
848 do {
849 p++;
851 while (nasm_isdigit(*p));
852 type = TOK_PREPROC_ID;
853 } else if (*p == '{') {
854 p++;
855 while (*p && *p != '}') {
856 p[-1] = *p;
857 p++;
859 p[-1] = '\0';
860 if (*p)
861 p++;
862 type = TOK_PREPROC_ID;
863 } else if (*p == '[') {
864 int lvl = 1;
865 line += 2; /* Skip the leading %[ */
866 p++;
867 while (lvl && (c = *p++)) {
868 switch (c) {
869 case ']':
870 lvl--;
871 break;
872 case '%':
873 if (*p == '[')
874 lvl++;
875 break;
876 case '\'':
877 case '\"':
878 case '`':
879 p = nasm_skip_string(p)+1;
880 break;
881 default:
882 break;
885 p--;
886 if (*p)
887 *p++ = '\0';
888 if (lvl)
889 error(ERR_NONFATAL, "unterminated %[ construct");
890 type = TOK_INDIRECT;
891 } else if (*p == '?') {
892 type = TOK_PREPROC_Q; /* %? */
893 p++;
894 if (*p == '?') {
895 type = TOK_PREPROC_QQ; /* %?? */
896 p++;
898 } else if (isidchar(*p) ||
899 ((*p == '!' || *p == '%' || *p == '$') &&
900 isidchar(p[1]))) {
901 do {
902 p++;
904 while (isidchar(*p));
905 type = TOK_PREPROC_ID;
906 } else {
907 type = TOK_OTHER;
908 if (*p == '%')
909 p++;
911 } else if (isidstart(*p) || (*p == '$' && isidstart(p[1]))) {
912 type = TOK_ID;
913 p++;
914 while (*p && isidchar(*p))
915 p++;
916 } else if (*p == '\'' || *p == '"' || *p == '`') {
918 * A string token.
920 type = TOK_STRING;
921 p = nasm_skip_string(p);
923 if (*p) {
924 p++;
925 } else {
926 error(ERR_WARNING|ERR_PASS1, "unterminated string");
927 /* Handling unterminated strings by UNV */
928 /* type = -1; */
930 } else if (p[0] == '$' && p[1] == '$') {
931 type = TOK_OTHER; /* TOKEN_BASE */
932 p += 2;
933 } else if (isnumstart(*p)) {
934 bool is_hex = false;
935 bool is_float = false;
936 bool has_e = false;
937 char c, *r;
940 * A numeric token.
943 if (*p == '$') {
944 p++;
945 is_hex = true;
948 for (;;) {
949 c = *p++;
951 if (!is_hex && (c == 'e' || c == 'E')) {
952 has_e = true;
953 if (*p == '+' || *p == '-') {
954 /* e can only be followed by +/- if it is either a
955 prefixed hex number or a floating-point number */
956 p++;
957 is_float = true;
959 } else if (c == 'H' || c == 'h' || c == 'X' || c == 'x') {
960 is_hex = true;
961 } else if (c == 'P' || c == 'p') {
962 is_float = true;
963 if (*p == '+' || *p == '-')
964 p++;
965 } else if (isnumchar(c) || c == '_')
966 ; /* just advance */
967 else if (c == '.') {
968 /* we need to deal with consequences of the legacy
969 parser, like "1.nolist" being two tokens
970 (TOK_NUMBER, TOK_ID) here; at least give it
971 a shot for now. In the future, we probably need
972 a flex-based scanner with proper pattern matching
973 to do it as well as it can be done. Nothing in
974 the world is going to help the person who wants
975 0x123.p16 interpreted as two tokens, though. */
976 r = p;
977 while (*r == '_')
978 r++;
980 if (nasm_isdigit(*r) || (is_hex && nasm_isxdigit(*r)) ||
981 (!is_hex && (*r == 'e' || *r == 'E')) ||
982 (*r == 'p' || *r == 'P')) {
983 p = r;
984 is_float = true;
985 } else
986 break; /* Terminate the token */
987 } else
988 break;
990 p--; /* Point to first character beyond number */
992 if (p == line+1 && *line == '$') {
993 type = TOK_OTHER; /* TOKEN_HERE */
994 } else {
995 if (has_e && !is_hex) {
996 /* 1e13 is floating-point, but 1e13h is not */
997 is_float = true;
1000 type = is_float ? TOK_FLOAT : TOK_NUMBER;
1002 } else if (nasm_isspace(*p)) {
1003 type = TOK_WHITESPACE;
1004 p++;
1005 while (*p && nasm_isspace(*p))
1006 p++;
1008 * Whitespace just before end-of-line is discarded by
1009 * pretending it's a comment; whitespace just before a
1010 * comment gets lumped into the comment.
1012 if (!*p || *p == ';') {
1013 type = TOK_COMMENT;
1014 while (*p)
1015 p++;
1017 } else if (*p == ';') {
1018 type = TOK_COMMENT;
1019 while (*p)
1020 p++;
1021 } else {
1023 * Anything else is an operator of some kind. We check
1024 * for all the double-character operators (>>, <<, //,
1025 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
1026 * else is a single-character operator.
1028 type = TOK_OTHER;
1029 if ((p[0] == '>' && p[1] == '>') ||
1030 (p[0] == '<' && p[1] == '<') ||
1031 (p[0] == '/' && p[1] == '/') ||
1032 (p[0] == '<' && p[1] == '=') ||
1033 (p[0] == '>' && p[1] == '=') ||
1034 (p[0] == '=' && p[1] == '=') ||
1035 (p[0] == '!' && p[1] == '=') ||
1036 (p[0] == '<' && p[1] == '>') ||
1037 (p[0] == '&' && p[1] == '&') ||
1038 (p[0] == '|' && p[1] == '|') ||
1039 (p[0] == '^' && p[1] == '^')) {
1040 p++;
1042 p++;
1045 /* Handling unterminated string by UNV */
1046 /*if (type == -1)
1048 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
1049 t->text[p-line] = *line;
1050 tail = &t->next;
1052 else */
1053 if (type != TOK_COMMENT) {
1054 *tail = t = new_Token(NULL, type, line, p - line);
1055 tail = &t->next;
1057 line = p;
1059 return list;
1063 * this function allocates a new managed block of memory and
1064 * returns a pointer to the block. The managed blocks are
1065 * deleted only all at once by the delete_Blocks function.
1067 static void *new_Block(size_t size)
1069 Blocks *b = &blocks;
1071 /* first, get to the end of the linked list */
1072 while (b->next)
1073 b = b->next;
1074 /* now allocate the requested chunk */
1075 b->chunk = nasm_malloc(size);
1077 /* now allocate a new block for the next request */
1078 b->next = nasm_malloc(sizeof(Blocks));
1079 /* and initialize the contents of the new block */
1080 b->next->next = NULL;
1081 b->next->chunk = NULL;
1082 return b->chunk;
1086 * this function deletes all managed blocks of memory
1088 static void delete_Blocks(void)
1090 Blocks *a, *b = &blocks;
1093 * keep in mind that the first block, pointed to by blocks
1094 * is a static and not dynamically allocated, so we don't
1095 * free it.
1097 while (b) {
1098 if (b->chunk)
1099 nasm_free(b->chunk);
1100 a = b;
1101 b = b->next;
1102 if (a != &blocks)
1103 nasm_free(a);
1108 * this function creates a new Token and passes a pointer to it
1109 * back to the caller. It sets the type and text elements, and
1110 * also the a.mac and next elements to NULL.
1112 static Token *new_Token(Token * next, enum pp_token_type type,
1113 const char *text, int txtlen)
1115 Token *t;
1116 int i;
1118 if (!freeTokens) {
1119 freeTokens = (Token *) new_Block(TOKEN_BLOCKSIZE * sizeof(Token));
1120 for (i = 0; i < TOKEN_BLOCKSIZE - 1; i++)
1121 freeTokens[i].next = &freeTokens[i + 1];
1122 freeTokens[i].next = NULL;
1124 t = freeTokens;
1125 freeTokens = t->next;
1126 t->next = next;
1127 t->a.mac = NULL;
1128 t->type = type;
1129 if (type == TOK_WHITESPACE || !text) {
1130 t->text = NULL;
1131 } else {
1132 if (txtlen == 0)
1133 txtlen = strlen(text);
1134 t->text = nasm_malloc(txtlen+1);
1135 memcpy(t->text, text, txtlen);
1136 t->text[txtlen] = '\0';
1138 return t;
1141 static Token *delete_Token(Token * t)
1143 Token *next = t->next;
1144 nasm_free(t->text);
1145 t->next = freeTokens;
1146 freeTokens = t;
1147 return next;
1151 * Convert a line of tokens back into text.
1152 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1153 * will be transformed into ..@ctxnum.xxx
1155 static char *detoken(Token * tlist, bool expand_locals)
1157 Token *t;
1158 int len;
1159 char *line, *p;
1160 const char *q;
1162 len = 0;
1163 for (t = tlist; t; t = t->next) {
1164 if (t->type == TOK_PREPROC_ID && t->text[1] == '!') {
1165 char *p = getenv(t->text + 2);
1166 nasm_free(t->text);
1167 if (p)
1168 t->text = nasm_strdup(p);
1169 else
1170 t->text = NULL;
1172 /* Expand local macros here and not during preprocessing */
1173 if (expand_locals &&
1174 t->type == TOK_PREPROC_ID && t->text &&
1175 t->text[0] == '%' && t->text[1] == '$') {
1176 const char *q;
1177 char *p;
1178 Context *ctx = get_ctx(t->text, &q, false);
1179 if (ctx) {
1180 char buffer[40];
1181 snprintf(buffer, sizeof(buffer), "..@%"PRIu32".", ctx->number);
1182 p = nasm_strcat(buffer, q);
1183 nasm_free(t->text);
1184 t->text = p;
1187 if (t->type == TOK_WHITESPACE) {
1188 len++;
1189 } else if (t->text) {
1190 len += strlen(t->text);
1193 p = line = nasm_malloc(len + 1);
1194 for (t = tlist; t; t = t->next) {
1195 if (t->type == TOK_WHITESPACE) {
1196 *p++ = ' ';
1197 } else if (t->text) {
1198 q = t->text;
1199 while (*q)
1200 *p++ = *q++;
1203 *p = '\0';
1204 return line;
1208 * A scanner, suitable for use by the expression evaluator, which
1209 * operates on a line of Tokens. Expects a pointer to a pointer to
1210 * the first token in the line to be passed in as its private_data
1211 * field.
1213 * FIX: This really needs to be unified with stdscan.
1215 static int ppscan(void *private_data, struct tokenval *tokval)
1217 Token **tlineptr = private_data;
1218 Token *tline;
1219 char ourcopy[MAX_KEYWORD+1], *p, *r, *s;
1221 do {
1222 tline = *tlineptr;
1223 *tlineptr = tline ? tline->next : NULL;
1225 while (tline && (tline->type == TOK_WHITESPACE ||
1226 tline->type == TOK_COMMENT));
1228 if (!tline)
1229 return tokval->t_type = TOKEN_EOS;
1231 tokval->t_charptr = tline->text;
1233 if (tline->text[0] == '$' && !tline->text[1])
1234 return tokval->t_type = TOKEN_HERE;
1235 if (tline->text[0] == '$' && tline->text[1] == '$' && !tline->text[2])
1236 return tokval->t_type = TOKEN_BASE;
1238 if (tline->type == TOK_ID) {
1239 p = tokval->t_charptr = tline->text;
1240 if (p[0] == '$') {
1241 tokval->t_charptr++;
1242 return tokval->t_type = TOKEN_ID;
1245 for (r = p, s = ourcopy; *r; r++) {
1246 if (r >= p+MAX_KEYWORD)
1247 return tokval->t_type = TOKEN_ID; /* Not a keyword */
1248 *s++ = nasm_tolower(*r);
1250 *s = '\0';
1251 /* right, so we have an identifier sitting in temp storage. now,
1252 * is it actually a register or instruction name, or what? */
1253 return nasm_token_hash(ourcopy, tokval);
1256 if (tline->type == TOK_NUMBER) {
1257 bool rn_error;
1258 tokval->t_integer = readnum(tline->text, &rn_error);
1259 tokval->t_charptr = tline->text;
1260 if (rn_error)
1261 return tokval->t_type = TOKEN_ERRNUM;
1262 else
1263 return tokval->t_type = TOKEN_NUM;
1266 if (tline->type == TOK_FLOAT) {
1267 return tokval->t_type = TOKEN_FLOAT;
1270 if (tline->type == TOK_STRING) {
1271 char bq, *ep;
1273 bq = tline->text[0];
1274 tokval->t_charptr = tline->text;
1275 tokval->t_inttwo = nasm_unquote(tline->text, &ep);
1277 if (ep[0] != bq || ep[1] != '\0')
1278 return tokval->t_type = TOKEN_ERRSTR;
1279 else
1280 return tokval->t_type = TOKEN_STR;
1283 if (tline->type == TOK_OTHER) {
1284 if (!strcmp(tline->text, "<<"))
1285 return tokval->t_type = TOKEN_SHL;
1286 if (!strcmp(tline->text, ">>"))
1287 return tokval->t_type = TOKEN_SHR;
1288 if (!strcmp(tline->text, "//"))
1289 return tokval->t_type = TOKEN_SDIV;
1290 if (!strcmp(tline->text, "%%"))
1291 return tokval->t_type = TOKEN_SMOD;
1292 if (!strcmp(tline->text, "=="))
1293 return tokval->t_type = TOKEN_EQ;
1294 if (!strcmp(tline->text, "<>"))
1295 return tokval->t_type = TOKEN_NE;
1296 if (!strcmp(tline->text, "!="))
1297 return tokval->t_type = TOKEN_NE;
1298 if (!strcmp(tline->text, "<="))
1299 return tokval->t_type = TOKEN_LE;
1300 if (!strcmp(tline->text, ">="))
1301 return tokval->t_type = TOKEN_GE;
1302 if (!strcmp(tline->text, "&&"))
1303 return tokval->t_type = TOKEN_DBL_AND;
1304 if (!strcmp(tline->text, "^^"))
1305 return tokval->t_type = TOKEN_DBL_XOR;
1306 if (!strcmp(tline->text, "||"))
1307 return tokval->t_type = TOKEN_DBL_OR;
1311 * We have no other options: just return the first character of
1312 * the token text.
1314 return tokval->t_type = tline->text[0];
1318 * Compare a string to the name of an existing macro; this is a
1319 * simple wrapper which calls either strcmp or nasm_stricmp
1320 * depending on the value of the `casesense' parameter.
1322 static int mstrcmp(const char *p, const char *q, bool casesense)
1324 return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
1328 * Compare a string to the name of an existing macro; this is a
1329 * simple wrapper which calls either strcmp or nasm_stricmp
1330 * depending on the value of the `casesense' parameter.
1332 static int mmemcmp(const char *p, const char *q, size_t l, bool casesense)
1334 return casesense ? memcmp(p, q, l) : nasm_memicmp(p, q, l);
1338 * Return the Context structure associated with a %$ token. Return
1339 * NULL, having _already_ reported an error condition, if the
1340 * context stack isn't deep enough for the supplied number of $
1341 * signs.
1342 * If all_contexts == true, contexts that enclose current are
1343 * also scanned for such smacro, until it is found; if not -
1344 * only the context that directly results from the number of $'s
1345 * in variable's name.
1347 * If "namep" is non-NULL, set it to the pointer to the macro name
1348 * tail, i.e. the part beyond %$...
1350 static Context *get_ctx(const char *name, const char **namep,
1351 bool all_contexts)
1353 Context *ctx;
1354 SMacro *m;
1355 int i;
1357 if (namep)
1358 *namep = name;
1360 if (!name || name[0] != '%' || name[1] != '$')
1361 return NULL;
1363 if (!cstk) {
1364 error(ERR_NONFATAL, "`%s': context stack is empty", name);
1365 return NULL;
1368 name += 2;
1369 ctx = cstk;
1370 i = 0;
1371 while (ctx && *name == '$') {
1372 name++;
1373 i++;
1374 ctx = ctx->next;
1376 if (!ctx) {
1377 error(ERR_NONFATAL, "`%s': context stack is only"
1378 " %d level%s deep", name, i, (i == 1 ? "" : "s"));
1379 return NULL;
1382 if (namep)
1383 *namep = name;
1385 if (!all_contexts)
1386 return ctx;
1388 do {
1389 /* Search for this smacro in found context */
1390 m = hash_findix(&ctx->localmac, name);
1391 while (m) {
1392 if (!mstrcmp(m->name, name, m->casesense))
1393 return ctx;
1394 m = m->next;
1396 ctx = ctx->next;
1398 while (ctx);
1399 return NULL;
1403 * Check to see if a file is already in a string list
1405 static bool in_list(const StrList *list, const char *str)
1407 while (list) {
1408 if (!strcmp(list->str, str))
1409 return true;
1410 list = list->next;
1412 return false;
1416 * Open an include file. This routine must always return a valid
1417 * file pointer if it returns - it's responsible for throwing an
1418 * ERR_FATAL and bombing out completely if not. It should also try
1419 * the include path one by one until it finds the file or reaches
1420 * the end of the path.
1422 static FILE *inc_fopen(const char *file, StrList **dhead, StrList ***dtail,
1423 bool missing_ok)
1425 FILE *fp;
1426 char *prefix = "";
1427 IncPath *ip = ipath;
1428 int len = strlen(file);
1429 size_t prefix_len = 0;
1430 StrList *sl;
1432 while (1) {
1433 sl = nasm_malloc(prefix_len+len+1+sizeof sl->next);
1434 memcpy(sl->str, prefix, prefix_len);
1435 memcpy(sl->str+prefix_len, file, len+1);
1436 fp = fopen(sl->str, "r");
1437 if (fp && dhead && !in_list(*dhead, sl->str)) {
1438 sl->next = NULL;
1439 **dtail = sl;
1440 *dtail = &sl->next;
1441 } else {
1442 nasm_free(sl);
1444 if (fp)
1445 return fp;
1446 if (!ip) {
1447 if (!missing_ok)
1448 break;
1449 prefix = NULL;
1450 } else {
1451 prefix = ip->path;
1452 ip = ip->next;
1454 if (prefix) {
1455 prefix_len = strlen(prefix);
1456 } else {
1457 /* -MG given and file not found */
1458 if (dhead && !in_list(*dhead, file)) {
1459 sl = nasm_malloc(len+1+sizeof sl->next);
1460 sl->next = NULL;
1461 strcpy(sl->str, file);
1462 **dtail = sl;
1463 *dtail = &sl->next;
1465 return NULL;
1469 error(ERR_FATAL, "unable to open include file `%s'", file);
1470 return NULL; /* never reached - placate compilers */
1474 * Determine if we should warn on defining a single-line macro of
1475 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1476 * return true if _any_ single-line macro of that name is defined.
1477 * Otherwise, will return true if a single-line macro with either
1478 * `nparam' or no parameters is defined.
1480 * If a macro with precisely the right number of parameters is
1481 * defined, or nparam is -1, the address of the definition structure
1482 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1483 * is NULL, no action will be taken regarding its contents, and no
1484 * error will occur.
1486 * Note that this is also called with nparam zero to resolve
1487 * `ifdef'.
1489 * If you already know which context macro belongs to, you can pass
1490 * the context pointer as first parameter; if you won't but name begins
1491 * with %$ the context will be automatically computed. If all_contexts
1492 * is true, macro will be searched in outer contexts as well.
1494 static bool
1495 smacro_defined(Context * ctx, const char *name, int nparam, SMacro ** defn,
1496 bool nocase)
1498 struct hash_table *smtbl;
1499 SMacro *m;
1501 if (ctx) {
1502 smtbl = &ctx->localmac;
1503 } else if (name[0] == '%' && name[1] == '$') {
1504 if (cstk)
1505 ctx = get_ctx(name, &name, false);
1506 if (!ctx)
1507 return false; /* got to return _something_ */
1508 smtbl = &ctx->localmac;
1509 } else {
1510 smtbl = &smacros;
1512 m = (SMacro *) hash_findix(smtbl, name);
1514 while (m) {
1515 if (!mstrcmp(m->name, name, m->casesense && nocase) &&
1516 (nparam <= 0 || m->nparam == 0 || nparam == (int) m->nparam)) {
1517 if (defn) {
1518 if (nparam == (int) m->nparam || nparam == -1)
1519 *defn = m;
1520 else
1521 *defn = NULL;
1523 return true;
1525 m = m->next;
1528 return false;
1532 * Count and mark off the parameters in a multi-line macro call.
1533 * This is called both from within the multi-line macro expansion
1534 * code, and also to mark off the default parameters when provided
1535 * in a %macro definition line.
1537 static void count_mmac_params(Token * t, int *nparam, Token *** params)
1539 int paramsize, brace;
1541 *nparam = paramsize = 0;
1542 *params = NULL;
1543 while (t) {
1544 /* +1: we need space for the final NULL */
1545 if (*nparam+1 >= paramsize) {
1546 paramsize += PARAM_DELTA;
1547 *params = nasm_realloc(*params, sizeof(**params) * paramsize);
1549 skip_white_(t);
1550 brace = false;
1551 if (tok_is_(t, "{"))
1552 brace = true;
1553 (*params)[(*nparam)++] = t;
1554 while (tok_isnt_(t, brace ? "}" : ","))
1555 t = t->next;
1556 if (t) { /* got a comma/brace */
1557 t = t->next;
1558 if (brace) {
1560 * Now we've found the closing brace, look further
1561 * for the comma.
1563 skip_white_(t);
1564 if (tok_isnt_(t, ",")) {
1565 error(ERR_NONFATAL,
1566 "braces do not enclose all of macro parameter");
1567 while (tok_isnt_(t, ","))
1568 t = t->next;
1570 if (t)
1571 t = t->next; /* eat the comma */
1578 * Determine whether one of the various `if' conditions is true or
1579 * not.
1581 * We must free the tline we get passed.
1583 static bool if_condition(Token * tline, enum preproc_token ct)
1585 enum pp_conditional i = PP_COND(ct);
1586 bool j;
1587 Token *t, *tt, **tptr, *origline;
1588 struct tokenval tokval;
1589 expr *evalresult;
1590 enum pp_token_type needtype;
1592 origline = tline;
1594 switch (i) {
1595 case PPC_IFCTX:
1596 j = false; /* have we matched yet? */
1597 while (true) {
1598 skip_white_(tline);
1599 if (!tline)
1600 break;
1601 if (tline->type != TOK_ID) {
1602 error(ERR_NONFATAL,
1603 "`%s' expects context identifiers", pp_directives[ct]);
1604 free_tlist(origline);
1605 return -1;
1607 if (cstk && cstk->name && !nasm_stricmp(tline->text, cstk->name))
1608 j = true;
1609 tline = tline->next;
1611 break;
1613 case PPC_IFDEF:
1614 j = false; /* have we matched yet? */
1615 while (tline) {
1616 skip_white_(tline);
1617 if (!tline || (tline->type != TOK_ID &&
1618 (tline->type != TOK_PREPROC_ID ||
1619 tline->text[1] != '$'))) {
1620 error(ERR_NONFATAL,
1621 "`%s' expects macro identifiers", pp_directives[ct]);
1622 goto fail;
1624 if (smacro_defined(NULL, tline->text, 0, NULL, true))
1625 j = true;
1626 tline = tline->next;
1628 break;
1630 case PPC_IFIDN:
1631 case PPC_IFIDNI:
1632 tline = expand_smacro(tline);
1633 t = tt = tline;
1634 while (tok_isnt_(tt, ","))
1635 tt = tt->next;
1636 if (!tt) {
1637 error(ERR_NONFATAL,
1638 "`%s' expects two comma-separated arguments",
1639 pp_directives[ct]);
1640 goto fail;
1642 tt = tt->next;
1643 j = true; /* assume equality unless proved not */
1644 while ((t->type != TOK_OTHER || strcmp(t->text, ",")) && tt) {
1645 if (tt->type == TOK_OTHER && !strcmp(tt->text, ",")) {
1646 error(ERR_NONFATAL, "`%s': more than one comma on line",
1647 pp_directives[ct]);
1648 goto fail;
1650 if (t->type == TOK_WHITESPACE) {
1651 t = t->next;
1652 continue;
1654 if (tt->type == TOK_WHITESPACE) {
1655 tt = tt->next;
1656 continue;
1658 if (tt->type != t->type) {
1659 j = false; /* found mismatching tokens */
1660 break;
1662 /* When comparing strings, need to unquote them first */
1663 if (t->type == TOK_STRING) {
1664 size_t l1 = nasm_unquote(t->text, NULL);
1665 size_t l2 = nasm_unquote(tt->text, NULL);
1667 if (l1 != l2) {
1668 j = false;
1669 break;
1671 if (mmemcmp(t->text, tt->text, l1, i == PPC_IFIDN)) {
1672 j = false;
1673 break;
1675 } else if (mstrcmp(tt->text, t->text, i == PPC_IFIDN) != 0) {
1676 j = false; /* found mismatching tokens */
1677 break;
1680 t = t->next;
1681 tt = tt->next;
1683 if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
1684 j = false; /* trailing gunk on one end or other */
1685 break;
1687 case PPC_IFMACRO:
1689 bool found = false;
1690 MMacro searching, *mmac;
1692 skip_white_(tline);
1693 tline = expand_id(tline);
1694 if (!tok_type_(tline, TOK_ID)) {
1695 error(ERR_NONFATAL,
1696 "`%s' expects a macro name", pp_directives[ct]);
1697 goto fail;
1699 searching.name = nasm_strdup(tline->text);
1700 searching.casesense = true;
1701 searching.plus = false;
1702 searching.nolist = false;
1703 searching.in_progress = 0;
1704 searching.max_depth = 0;
1705 searching.rep_nest = NULL;
1706 searching.nparam_min = 0;
1707 searching.nparam_max = INT_MAX;
1708 tline = expand_smacro(tline->next);
1709 skip_white_(tline);
1710 if (!tline) {
1711 } else if (!tok_type_(tline, TOK_NUMBER)) {
1712 error(ERR_NONFATAL,
1713 "`%s' expects a parameter count or nothing",
1714 pp_directives[ct]);
1715 } else {
1716 searching.nparam_min = searching.nparam_max =
1717 readnum(tline->text, &j);
1718 if (j)
1719 error(ERR_NONFATAL,
1720 "unable to parse parameter count `%s'",
1721 tline->text);
1723 if (tline && tok_is_(tline->next, "-")) {
1724 tline = tline->next->next;
1725 if (tok_is_(tline, "*"))
1726 searching.nparam_max = INT_MAX;
1727 else if (!tok_type_(tline, TOK_NUMBER))
1728 error(ERR_NONFATAL,
1729 "`%s' expects a parameter count after `-'",
1730 pp_directives[ct]);
1731 else {
1732 searching.nparam_max = readnum(tline->text, &j);
1733 if (j)
1734 error(ERR_NONFATAL,
1735 "unable to parse parameter count `%s'",
1736 tline->text);
1737 if (searching.nparam_min > searching.nparam_max)
1738 error(ERR_NONFATAL,
1739 "minimum parameter count exceeds maximum");
1742 if (tline && tok_is_(tline->next, "+")) {
1743 tline = tline->next;
1744 searching.plus = true;
1746 mmac = (MMacro *) hash_findix(&mmacros, searching.name);
1747 while (mmac) {
1748 if (!strcmp(mmac->name, searching.name) &&
1749 (mmac->nparam_min <= searching.nparam_max
1750 || searching.plus)
1751 && (searching.nparam_min <= mmac->nparam_max
1752 || mmac->plus)) {
1753 found = true;
1754 break;
1756 mmac = mmac->next;
1758 if (tline && tline->next)
1759 error(ERR_WARNING|ERR_PASS1,
1760 "trailing garbage after %%ifmacro ignored");
1761 nasm_free(searching.name);
1762 j = found;
1763 break;
1766 case PPC_IFID:
1767 needtype = TOK_ID;
1768 goto iftype;
1769 case PPC_IFNUM:
1770 needtype = TOK_NUMBER;
1771 goto iftype;
1772 case PPC_IFSTR:
1773 needtype = TOK_STRING;
1774 goto iftype;
1776 iftype:
1777 t = tline = expand_smacro(tline);
1779 while (tok_type_(t, TOK_WHITESPACE) ||
1780 (needtype == TOK_NUMBER &&
1781 tok_type_(t, TOK_OTHER) &&
1782 (t->text[0] == '-' || t->text[0] == '+') &&
1783 !t->text[1]))
1784 t = t->next;
1786 j = tok_type_(t, needtype);
1787 break;
1789 case PPC_IFTOKEN:
1790 t = tline = expand_smacro(tline);
1791 while (tok_type_(t, TOK_WHITESPACE))
1792 t = t->next;
1794 j = false;
1795 if (t) {
1796 t = t->next; /* Skip the actual token */
1797 while (tok_type_(t, TOK_WHITESPACE))
1798 t = t->next;
1799 j = !t; /* Should be nothing left */
1801 break;
1803 case PPC_IFEMPTY:
1804 t = tline = expand_smacro(tline);
1805 while (tok_type_(t, TOK_WHITESPACE))
1806 t = t->next;
1808 j = !t; /* Should be empty */
1809 break;
1811 case PPC_IF:
1812 t = tline = expand_smacro(tline);
1813 tptr = &t;
1814 tokval.t_type = TOKEN_INVALID;
1815 evalresult = evaluate(ppscan, tptr, &tokval,
1816 NULL, pass | CRITICAL, error, NULL);
1817 if (!evalresult)
1818 return -1;
1819 if (tokval.t_type)
1820 error(ERR_WARNING|ERR_PASS1,
1821 "trailing garbage after expression ignored");
1822 if (!is_simple(evalresult)) {
1823 error(ERR_NONFATAL,
1824 "non-constant value given to `%s'", pp_directives[ct]);
1825 goto fail;
1827 j = reloc_value(evalresult) != 0;
1828 break;
1830 default:
1831 error(ERR_FATAL,
1832 "preprocessor directive `%s' not yet implemented",
1833 pp_directives[ct]);
1834 goto fail;
1837 free_tlist(origline);
1838 return j ^ PP_NEGATIVE(ct);
1840 fail:
1841 free_tlist(origline);
1842 return -1;
1846 * Common code for defining an smacro
1848 static bool define_smacro(Context *ctx, const char *mname, bool casesense,
1849 int nparam, Token *expansion)
1851 SMacro *smac, **smhead;
1852 struct hash_table *smtbl;
1854 if (smacro_defined(ctx, mname, nparam, &smac, casesense)) {
1855 if (!smac) {
1856 error(ERR_WARNING|ERR_PASS1,
1857 "single-line macro `%s' defined both with and"
1858 " without parameters", mname);
1860 /* Some instances of the old code considered this a failure,
1861 some others didn't. What is the right thing to do here? */
1862 free_tlist(expansion);
1863 return false; /* Failure */
1864 } else {
1866 * We're redefining, so we have to take over an
1867 * existing SMacro structure. This means freeing
1868 * what was already in it.
1870 nasm_free(smac->name);
1871 free_tlist(smac->expansion);
1873 } else {
1874 smtbl = ctx ? &ctx->localmac : &smacros;
1875 smhead = (SMacro **) hash_findi_add(smtbl, mname);
1876 smac = nasm_malloc(sizeof(SMacro));
1877 smac->next = *smhead;
1878 *smhead = smac;
1880 smac->name = nasm_strdup(mname);
1881 smac->casesense = casesense;
1882 smac->nparam = nparam;
1883 smac->expansion = expansion;
1884 smac->in_progress = false;
1885 return true; /* Success */
1889 * Undefine an smacro
1891 static void undef_smacro(Context *ctx, const char *mname)
1893 SMacro **smhead, *s, **sp;
1894 struct hash_table *smtbl;
1896 smtbl = ctx ? &ctx->localmac : &smacros;
1897 smhead = (SMacro **)hash_findi(smtbl, mname, NULL);
1899 if (smhead) {
1901 * We now have a macro name... go hunt for it.
1903 sp = smhead;
1904 while ((s = *sp) != NULL) {
1905 if (!mstrcmp(s->name, mname, s->casesense)) {
1906 *sp = s->next;
1907 nasm_free(s->name);
1908 free_tlist(s->expansion);
1909 nasm_free(s);
1910 } else {
1911 sp = &s->next;
1918 * Parse a mmacro specification.
1920 static bool parse_mmacro_spec(Token *tline, MMacro *def, const char *directive)
1922 bool err;
1924 tline = tline->next;
1925 skip_white_(tline);
1926 tline = expand_id(tline);
1927 if (!tok_type_(tline, TOK_ID)) {
1928 error(ERR_NONFATAL, "`%s' expects a macro name", directive);
1929 return false;
1932 def->prev = NULL;
1933 def->name = nasm_strdup(tline->text);
1934 def->plus = false;
1935 def->nolist = false;
1936 def->in_progress = 0;
1937 def->rep_nest = NULL;
1938 def->nparam_min = 0;
1939 def->nparam_max = 0;
1941 tline = expand_smacro(tline->next);
1942 skip_white_(tline);
1943 if (!tok_type_(tline, TOK_NUMBER)) {
1944 error(ERR_NONFATAL, "`%s' expects a parameter count", directive);
1945 } else {
1946 def->nparam_min = def->nparam_max =
1947 readnum(tline->text, &err);
1948 if (err)
1949 error(ERR_NONFATAL,
1950 "unable to parse parameter count `%s'", tline->text);
1952 if (tline && tok_is_(tline->next, "-")) {
1953 tline = tline->next->next;
1954 if (tok_is_(tline, "*")) {
1955 def->nparam_max = INT_MAX;
1956 } else if (!tok_type_(tline, TOK_NUMBER)) {
1957 error(ERR_NONFATAL,
1958 "`%s' expects a parameter count after `-'", directive);
1959 } else {
1960 def->nparam_max = readnum(tline->text, &err);
1961 if (err) {
1962 error(ERR_NONFATAL, "unable to parse parameter count `%s'",
1963 tline->text);
1965 if (def->nparam_min > def->nparam_max) {
1966 error(ERR_NONFATAL, "minimum parameter count exceeds maximum");
1970 if (tline && tok_is_(tline->next, "+")) {
1971 tline = tline->next;
1972 def->plus = true;
1974 if (tline && tok_type_(tline->next, TOK_ID) &&
1975 !nasm_stricmp(tline->next->text, ".nolist")) {
1976 tline = tline->next;
1977 def->nolist = true;
1981 * Handle default parameters.
1983 if (tline && tline->next) {
1984 def->dlist = tline->next;
1985 tline->next = NULL;
1986 count_mmac_params(def->dlist, &def->ndefs, &def->defaults);
1987 } else {
1988 def->dlist = NULL;
1989 def->defaults = NULL;
1991 def->expansion = NULL;
1993 if (def->defaults && def->ndefs > def->nparam_max - def->nparam_min &&
1994 !def->plus)
1995 error(ERR_WARNING|ERR_PASS1|ERR_WARN_MDP,
1996 "too many default macro parameters");
1998 return true;
2003 * Decode a size directive
2005 static int parse_size(const char *str) {
2006 static const char *size_names[] =
2007 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
2008 static const int sizes[] =
2009 { 0, 1, 4, 16, 8, 10, 2, 32 };
2011 return sizes[bsii(str, size_names, elements(size_names))+1];
2015 * nasm_unquote with error if the string contains NUL characters.
2016 * If the string contains NUL characters, issue an error and return
2017 * the C len, i.e. truncate at the NUL.
2019 static size_t nasm_unquote_cstr(char *qstr, enum preproc_token directive)
2021 size_t len = nasm_unquote(qstr, NULL);
2022 size_t clen = strlen(qstr);
2024 if (len != clen)
2025 error(ERR_NONFATAL, "NUL character in `%s' directive",
2026 pp_directives[directive]);
2028 return clen;
2032 * find and process preprocessor directive in passed line
2033 * Find out if a line contains a preprocessor directive, and deal
2034 * with it if so.
2036 * If a directive _is_ found, it is the responsibility of this routine
2037 * (and not the caller) to free_tlist() the line.
2039 * @param tline a pointer to the current tokeninzed line linked list
2040 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
2043 static int do_directive(Token * tline)
2045 enum preproc_token i;
2046 int j;
2047 bool err;
2048 int nparam;
2049 bool nolist;
2050 bool casesense;
2051 int k, m;
2052 int offset;
2053 char *p, *pp;
2054 const char *mname;
2055 Include *inc;
2056 Context *ctx;
2057 Cond *cond;
2058 MMacro *mmac, **mmhead;
2059 Token *t, *tt, *param_start, *macro_start, *last, **tptr, *origline;
2060 Line *l;
2061 struct tokenval tokval;
2062 expr *evalresult;
2063 MMacro *tmp_defining; /* Used when manipulating rep_nest */
2064 int64_t count;
2065 size_t len;
2066 int severity;
2068 origline = tline;
2070 skip_white_(tline);
2071 if (!tline || !tok_type_(tline, TOK_PREPROC_ID) ||
2072 (tline->text[1] == '%' || tline->text[1] == '$'
2073 || tline->text[1] == '!'))
2074 return NO_DIRECTIVE_FOUND;
2076 i = pp_token_hash(tline->text);
2079 * If we're in a non-emitting branch of a condition construct,
2080 * or walking to the end of an already terminated %rep block,
2081 * we should ignore all directives except for condition
2082 * directives.
2084 if (((istk->conds && !emitting(istk->conds->state)) ||
2085 (istk->mstk && !istk->mstk->in_progress)) && !is_condition(i)) {
2086 return NO_DIRECTIVE_FOUND;
2090 * If we're defining a macro or reading a %rep block, we should
2091 * ignore all directives except for %macro/%imacro (which nest),
2092 * %endm/%endmacro, and (only if we're in a %rep block) %endrep.
2093 * If we're in a %rep block, another %rep nests, so should be let through.
2095 if (defining && i != PP_MACRO && i != PP_IMACRO &&
2096 i != PP_RMACRO && i != PP_IRMACRO &&
2097 i != PP_ENDMACRO && i != PP_ENDM &&
2098 (defining->name || (i != PP_ENDREP && i != PP_REP))) {
2099 return NO_DIRECTIVE_FOUND;
2102 if (defining) {
2103 if (i == PP_MACRO || i == PP_IMACRO ||
2104 i == PP_RMACRO || i == PP_IRMACRO) {
2105 nested_mac_count++;
2106 return NO_DIRECTIVE_FOUND;
2107 } else if (nested_mac_count > 0) {
2108 if (i == PP_ENDMACRO) {
2109 nested_mac_count--;
2110 return NO_DIRECTIVE_FOUND;
2113 if (!defining->name) {
2114 if (i == PP_REP) {
2115 nested_rep_count++;
2116 return NO_DIRECTIVE_FOUND;
2117 } else if (nested_rep_count > 0) {
2118 if (i == PP_ENDREP) {
2119 nested_rep_count--;
2120 return NO_DIRECTIVE_FOUND;
2126 switch (i) {
2127 case PP_INVALID:
2128 error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
2129 tline->text);
2130 return NO_DIRECTIVE_FOUND; /* didn't get it */
2132 case PP_STACKSIZE:
2133 /* Directive to tell NASM what the default stack size is. The
2134 * default is for a 16-bit stack, and this can be overriden with
2135 * %stacksize large.
2136 * the following form:
2138 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2140 tline = tline->next;
2141 if (tline && tline->type == TOK_WHITESPACE)
2142 tline = tline->next;
2143 if (!tline || tline->type != TOK_ID) {
2144 error(ERR_NONFATAL, "`%%stacksize' missing size parameter");
2145 free_tlist(origline);
2146 return DIRECTIVE_FOUND;
2148 if (nasm_stricmp(tline->text, "flat") == 0) {
2149 /* All subsequent ARG directives are for a 32-bit stack */
2150 StackSize = 4;
2151 StackPointer = "ebp";
2152 ArgOffset = 8;
2153 LocalOffset = 0;
2154 } else if (nasm_stricmp(tline->text, "flat64") == 0) {
2155 /* All subsequent ARG directives are for a 64-bit stack */
2156 StackSize = 8;
2157 StackPointer = "rbp";
2158 ArgOffset = 8;
2159 LocalOffset = 0;
2160 } else if (nasm_stricmp(tline->text, "large") == 0) {
2161 /* All subsequent ARG directives are for a 16-bit stack,
2162 * far function call.
2164 StackSize = 2;
2165 StackPointer = "bp";
2166 ArgOffset = 4;
2167 LocalOffset = 0;
2168 } else if (nasm_stricmp(tline->text, "small") == 0) {
2169 /* All subsequent ARG directives are for a 16-bit stack,
2170 * far function call. We don't support near functions.
2172 StackSize = 2;
2173 StackPointer = "bp";
2174 ArgOffset = 6;
2175 LocalOffset = 0;
2176 } else {
2177 error(ERR_NONFATAL, "`%%stacksize' invalid size type");
2178 free_tlist(origline);
2179 return DIRECTIVE_FOUND;
2181 free_tlist(origline);
2182 return DIRECTIVE_FOUND;
2184 case PP_ARG:
2185 /* TASM like ARG directive to define arguments to functions, in
2186 * the following form:
2188 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2190 offset = ArgOffset;
2191 do {
2192 char *arg, directive[256];
2193 int size = StackSize;
2195 /* Find the argument name */
2196 tline = tline->next;
2197 if (tline && tline->type == TOK_WHITESPACE)
2198 tline = tline->next;
2199 if (!tline || tline->type != TOK_ID) {
2200 error(ERR_NONFATAL, "`%%arg' missing argument parameter");
2201 free_tlist(origline);
2202 return DIRECTIVE_FOUND;
2204 arg = tline->text;
2206 /* Find the argument size type */
2207 tline = tline->next;
2208 if (!tline || tline->type != TOK_OTHER
2209 || tline->text[0] != ':') {
2210 error(ERR_NONFATAL,
2211 "Syntax error processing `%%arg' directive");
2212 free_tlist(origline);
2213 return DIRECTIVE_FOUND;
2215 tline = tline->next;
2216 if (!tline || tline->type != TOK_ID) {
2217 error(ERR_NONFATAL, "`%%arg' missing size type parameter");
2218 free_tlist(origline);
2219 return DIRECTIVE_FOUND;
2222 /* Allow macro expansion of type parameter */
2223 tt = tokenize(tline->text);
2224 tt = expand_smacro(tt);
2225 size = parse_size(tt->text);
2226 if (!size) {
2227 error(ERR_NONFATAL,
2228 "Invalid size type for `%%arg' missing directive");
2229 free_tlist(tt);
2230 free_tlist(origline);
2231 return DIRECTIVE_FOUND;
2233 free_tlist(tt);
2235 /* Round up to even stack slots */
2236 size = (size+StackSize-1) & ~(StackSize-1);
2238 /* Now define the macro for the argument */
2239 snprintf(directive, sizeof(directive), "%%define %s (%s+%d)",
2240 arg, StackPointer, offset);
2241 do_directive(tokenize(directive));
2242 offset += size;
2244 /* Move to the next argument in the list */
2245 tline = tline->next;
2246 if (tline && tline->type == TOK_WHITESPACE)
2247 tline = tline->next;
2248 } while (tline && tline->type == TOK_OTHER && tline->text[0] == ',');
2249 ArgOffset = offset;
2250 free_tlist(origline);
2251 return DIRECTIVE_FOUND;
2253 case PP_LOCAL:
2254 /* TASM like LOCAL directive to define local variables for a
2255 * function, in the following form:
2257 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2259 * The '= LocalSize' at the end is ignored by NASM, but is
2260 * required by TASM to define the local parameter size (and used
2261 * by the TASM macro package).
2263 offset = LocalOffset;
2264 do {
2265 char *local, directive[256];
2266 int size = StackSize;
2268 /* Find the argument name */
2269 tline = tline->next;
2270 if (tline && tline->type == TOK_WHITESPACE)
2271 tline = tline->next;
2272 if (!tline || tline->type != TOK_ID) {
2273 error(ERR_NONFATAL,
2274 "`%%local' missing argument parameter");
2275 free_tlist(origline);
2276 return DIRECTIVE_FOUND;
2278 local = tline->text;
2280 /* Find the argument size type */
2281 tline = tline->next;
2282 if (!tline || tline->type != TOK_OTHER
2283 || tline->text[0] != ':') {
2284 error(ERR_NONFATAL,
2285 "Syntax error processing `%%local' directive");
2286 free_tlist(origline);
2287 return DIRECTIVE_FOUND;
2289 tline = tline->next;
2290 if (!tline || tline->type != TOK_ID) {
2291 error(ERR_NONFATAL,
2292 "`%%local' missing size type parameter");
2293 free_tlist(origline);
2294 return DIRECTIVE_FOUND;
2297 /* Allow macro expansion of type parameter */
2298 tt = tokenize(tline->text);
2299 tt = expand_smacro(tt);
2300 size = parse_size(tt->text);
2301 if (!size) {
2302 error(ERR_NONFATAL,
2303 "Invalid size type for `%%local' missing directive");
2304 free_tlist(tt);
2305 free_tlist(origline);
2306 return DIRECTIVE_FOUND;
2308 free_tlist(tt);
2310 /* Round up to even stack slots */
2311 size = (size+StackSize-1) & ~(StackSize-1);
2313 offset += size; /* Negative offset, increment before */
2315 /* Now define the macro for the argument */
2316 snprintf(directive, sizeof(directive), "%%define %s (%s-%d)",
2317 local, StackPointer, offset);
2318 do_directive(tokenize(directive));
2320 /* Now define the assign to setup the enter_c macro correctly */
2321 snprintf(directive, sizeof(directive),
2322 "%%assign %%$localsize %%$localsize+%d", size);
2323 do_directive(tokenize(directive));
2325 /* Move to the next argument in the list */
2326 tline = tline->next;
2327 if (tline && tline->type == TOK_WHITESPACE)
2328 tline = tline->next;
2329 } while (tline && tline->type == TOK_OTHER && tline->text[0] == ',');
2330 LocalOffset = offset;
2331 free_tlist(origline);
2332 return DIRECTIVE_FOUND;
2334 case PP_CLEAR:
2335 if (tline->next)
2336 error(ERR_WARNING|ERR_PASS1,
2337 "trailing garbage after `%%clear' ignored");
2338 free_macros();
2339 init_macros();
2340 free_tlist(origline);
2341 return DIRECTIVE_FOUND;
2343 case PP_DEPEND:
2344 t = tline->next = expand_smacro(tline->next);
2345 skip_white_(t);
2346 if (!t || (t->type != TOK_STRING &&
2347 t->type != TOK_INTERNAL_STRING)) {
2348 error(ERR_NONFATAL, "`%%depend' expects a file name");
2349 free_tlist(origline);
2350 return DIRECTIVE_FOUND; /* but we did _something_ */
2352 if (t->next)
2353 error(ERR_WARNING|ERR_PASS1,
2354 "trailing garbage after `%%depend' ignored");
2355 p = t->text;
2356 if (t->type != TOK_INTERNAL_STRING)
2357 nasm_unquote_cstr(p, i);
2358 if (dephead && !in_list(*dephead, p)) {
2359 StrList *sl = nasm_malloc(strlen(p)+1+sizeof sl->next);
2360 sl->next = NULL;
2361 strcpy(sl->str, p);
2362 *deptail = sl;
2363 deptail = &sl->next;
2365 free_tlist(origline);
2366 return DIRECTIVE_FOUND;
2368 case PP_INCLUDE:
2369 t = tline->next = expand_smacro(tline->next);
2370 skip_white_(t);
2372 if (!t || (t->type != TOK_STRING &&
2373 t->type != TOK_INTERNAL_STRING)) {
2374 error(ERR_NONFATAL, "`%%include' expects a file name");
2375 free_tlist(origline);
2376 return DIRECTIVE_FOUND; /* but we did _something_ */
2378 if (t->next)
2379 error(ERR_WARNING|ERR_PASS1,
2380 "trailing garbage after `%%include' ignored");
2381 p = t->text;
2382 if (t->type != TOK_INTERNAL_STRING)
2383 nasm_unquote_cstr(p, i);
2384 inc = nasm_malloc(sizeof(Include));
2385 inc->next = istk;
2386 inc->conds = NULL;
2387 inc->fp = inc_fopen(p, dephead, &deptail, pass == 0);
2388 if (!inc->fp) {
2389 /* -MG given but file not found */
2390 nasm_free(inc);
2391 } else {
2392 inc->fname = src_set_fname(nasm_strdup(p));
2393 inc->lineno = src_set_linnum(0);
2394 inc->lineinc = 1;
2395 inc->expansion = NULL;
2396 inc->mstk = NULL;
2397 istk = inc;
2398 list->uplevel(LIST_INCLUDE);
2400 free_tlist(origline);
2401 return DIRECTIVE_FOUND;
2403 case PP_USE:
2405 static macros_t *use_pkg;
2406 const char *pkg_macro;
2408 tline = tline->next;
2409 skip_white_(tline);
2410 tline = expand_id(tline);
2412 if (!tline || (tline->type != TOK_STRING &&
2413 tline->type != TOK_INTERNAL_STRING &&
2414 tline->type != TOK_ID)) {
2415 error(ERR_NONFATAL, "`%%use' expects a package name");
2416 free_tlist(origline);
2417 return DIRECTIVE_FOUND; /* but we did _something_ */
2419 if (tline->next)
2420 error(ERR_WARNING|ERR_PASS1,
2421 "trailing garbage after `%%use' ignored");
2422 if (tline->type == TOK_STRING)
2423 nasm_unquote_cstr(tline->text, i);
2424 use_pkg = nasm_stdmac_find_package(tline->text);
2425 if (!use_pkg)
2426 error(ERR_NONFATAL, "unknown `%%use' package: %s", tline->text);
2427 /* The first string will be <%define>__USE_*__ */
2428 pkg_macro = (char *)use_pkg + 1;
2429 if (!smacro_defined(NULL, pkg_macro, 0, NULL, true)) {
2430 /* Not already included, go ahead and include it */
2431 stdmacpos = use_pkg;
2433 free_tlist(origline);
2434 return DIRECTIVE_FOUND;
2436 case PP_PUSH:
2437 case PP_REPL:
2438 case PP_POP:
2439 tline = tline->next;
2440 skip_white_(tline);
2441 tline = expand_id(tline);
2442 if (tline) {
2443 if (!tok_type_(tline, TOK_ID)) {
2444 error(ERR_NONFATAL, "`%s' expects a context identifier",
2445 pp_directives[i]);
2446 free_tlist(origline);
2447 return DIRECTIVE_FOUND; /* but we did _something_ */
2449 if (tline->next)
2450 error(ERR_WARNING|ERR_PASS1,
2451 "trailing garbage after `%s' ignored",
2452 pp_directives[i]);
2453 p = nasm_strdup(tline->text);
2454 } else {
2455 p = NULL; /* Anonymous */
2458 if (i == PP_PUSH) {
2459 ctx = nasm_malloc(sizeof(Context));
2460 ctx->next = cstk;
2461 hash_init(&ctx->localmac, HASH_SMALL);
2462 ctx->name = p;
2463 ctx->number = unique++;
2464 cstk = ctx;
2465 } else {
2466 /* %pop or %repl */
2467 if (!cstk) {
2468 error(ERR_NONFATAL, "`%s': context stack is empty",
2469 pp_directives[i]);
2470 } else if (i == PP_POP) {
2471 if (p && (!cstk->name || nasm_stricmp(p, cstk->name)))
2472 error(ERR_NONFATAL, "`%%pop' in wrong context: %s, "
2473 "expected %s",
2474 cstk->name ? cstk->name : "anonymous", p);
2475 else
2476 ctx_pop();
2477 } else {
2478 /* i == PP_REPL */
2479 nasm_free(cstk->name);
2480 cstk->name = p;
2481 p = NULL;
2483 nasm_free(p);
2485 free_tlist(origline);
2486 return DIRECTIVE_FOUND;
2487 case PP_FATAL:
2488 severity = ERR_FATAL;
2489 goto issue_error;
2490 case PP_ERROR:
2491 severity = ERR_NONFATAL;
2492 goto issue_error;
2493 case PP_WARNING:
2494 severity = ERR_WARNING|ERR_WARN_USER;
2495 goto issue_error;
2497 issue_error:
2499 /* Only error out if this is the final pass */
2500 if (pass != 2 && i != PP_FATAL)
2501 return DIRECTIVE_FOUND;
2503 tline->next = expand_smacro(tline->next);
2504 tline = tline->next;
2505 skip_white_(tline);
2506 t = tline ? tline->next : NULL;
2507 skip_white_(t);
2508 if (tok_type_(tline, TOK_STRING) && !t) {
2509 /* The line contains only a quoted string */
2510 p = tline->text;
2511 nasm_unquote(p, NULL); /* Ignore NUL character truncation */
2512 error(severity, "%s", p);
2513 } else {
2514 /* Not a quoted string, or more than a quoted string */
2515 p = detoken(tline, false);
2516 error(severity, "%s", p);
2517 nasm_free(p);
2519 free_tlist(origline);
2520 return DIRECTIVE_FOUND;
2523 CASE_PP_IF:
2524 if (istk->conds && !emitting(istk->conds->state))
2525 j = COND_NEVER;
2526 else {
2527 j = if_condition(tline->next, i);
2528 tline->next = NULL; /* it got freed */
2529 j = j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2531 cond = nasm_malloc(sizeof(Cond));
2532 cond->next = istk->conds;
2533 cond->state = j;
2534 istk->conds = cond;
2535 free_tlist(origline);
2536 return DIRECTIVE_FOUND;
2538 CASE_PP_ELIF:
2539 if (!istk->conds)
2540 error(ERR_FATAL, "`%s': no matching `%%if'", pp_directives[i]);
2541 switch(istk->conds->state) {
2542 case COND_IF_TRUE:
2543 istk->conds->state = COND_DONE;
2544 break;
2546 case COND_DONE:
2547 case COND_NEVER:
2548 break;
2550 case COND_ELSE_TRUE:
2551 case COND_ELSE_FALSE:
2552 error_precond(ERR_WARNING|ERR_PASS1,
2553 "`%%elif' after `%%else' ignored");
2554 istk->conds->state = COND_NEVER;
2555 break;
2557 case COND_IF_FALSE:
2559 * IMPORTANT: In the case of %if, we will already have
2560 * called expand_mmac_params(); however, if we're
2561 * processing an %elif we must have been in a
2562 * non-emitting mode, which would have inhibited
2563 * the normal invocation of expand_mmac_params().
2564 * Therefore, we have to do it explicitly here.
2566 j = if_condition(expand_mmac_params(tline->next), i);
2567 tline->next = NULL; /* it got freed */
2568 istk->conds->state =
2569 j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2570 break;
2572 free_tlist(origline);
2573 return DIRECTIVE_FOUND;
2575 case PP_ELSE:
2576 if (tline->next)
2577 error_precond(ERR_WARNING|ERR_PASS1,
2578 "trailing garbage after `%%else' ignored");
2579 if (!istk->conds)
2580 error(ERR_FATAL, "`%%else': no matching `%%if'");
2581 switch(istk->conds->state) {
2582 case COND_IF_TRUE:
2583 case COND_DONE:
2584 istk->conds->state = COND_ELSE_FALSE;
2585 break;
2587 case COND_NEVER:
2588 break;
2590 case COND_IF_FALSE:
2591 istk->conds->state = COND_ELSE_TRUE;
2592 break;
2594 case COND_ELSE_TRUE:
2595 case COND_ELSE_FALSE:
2596 error_precond(ERR_WARNING|ERR_PASS1,
2597 "`%%else' after `%%else' ignored.");
2598 istk->conds->state = COND_NEVER;
2599 break;
2601 free_tlist(origline);
2602 return DIRECTIVE_FOUND;
2604 case PP_ENDIF:
2605 if (tline->next)
2606 error_precond(ERR_WARNING|ERR_PASS1,
2607 "trailing garbage after `%%endif' ignored");
2608 if (!istk->conds)
2609 error(ERR_FATAL, "`%%endif': no matching `%%if'");
2610 cond = istk->conds;
2611 istk->conds = cond->next;
2612 nasm_free(cond);
2613 free_tlist(origline);
2614 return DIRECTIVE_FOUND;
2616 case PP_RMACRO:
2617 case PP_IRMACRO:
2618 case PP_MACRO:
2619 case PP_IMACRO:
2620 if (defining) {
2621 error(ERR_FATAL, "`%s': already defining a macro",
2622 pp_directives[i]);
2623 return DIRECTIVE_FOUND;
2625 defining = nasm_malloc(sizeof(MMacro));
2626 defining->max_depth =
2627 (i == PP_RMACRO) || (i == PP_IRMACRO) ? DEADMAN_LIMIT : 0;
2628 defining->casesense = (i == PP_MACRO) || (i == PP_RMACRO);
2629 if (!parse_mmacro_spec(tline, defining, pp_directives[i])) {
2630 nasm_free(defining);
2631 defining = NULL;
2632 return DIRECTIVE_FOUND;
2635 mmac = (MMacro *) hash_findix(&mmacros, defining->name);
2636 while (mmac) {
2637 if (!strcmp(mmac->name, defining->name) &&
2638 (mmac->nparam_min <= defining->nparam_max
2639 || defining->plus)
2640 && (defining->nparam_min <= mmac->nparam_max
2641 || mmac->plus)) {
2642 error(ERR_WARNING|ERR_PASS1,
2643 "redefining multi-line macro `%s'", defining->name);
2644 return DIRECTIVE_FOUND;
2646 mmac = mmac->next;
2648 free_tlist(origline);
2649 return DIRECTIVE_FOUND;
2651 case PP_ENDM:
2652 case PP_ENDMACRO:
2653 if (! (defining && defining->name)) {
2654 error(ERR_NONFATAL, "`%s': not defining a macro", tline->text);
2655 return DIRECTIVE_FOUND;
2657 mmhead = (MMacro **) hash_findi_add(&mmacros, defining->name);
2658 defining->next = *mmhead;
2659 *mmhead = defining;
2660 defining = NULL;
2661 free_tlist(origline);
2662 return DIRECTIVE_FOUND;
2664 case PP_EXITMACRO:
2666 * We must search along istk->expansion until we hit a
2667 * macro-end marker for a macro with a name. Then we set
2668 * its `in_progress' flag to 0.
2670 for (l = istk->expansion; l; l = l->next)
2671 if (l->finishes && l->finishes->name)
2672 break;
2674 if (l) {
2675 l->finishes->in_progress = 0;
2676 } else {
2677 error(ERR_NONFATAL, "`%%exitmacro' not within `%%macro' block");
2679 free_tlist(origline);
2680 return DIRECTIVE_FOUND;
2682 case PP_UNMACRO:
2683 case PP_UNIMACRO:
2685 MMacro **mmac_p;
2686 MMacro spec;
2688 spec.casesense = (i == PP_UNMACRO);
2689 if (!parse_mmacro_spec(tline, &spec, pp_directives[i])) {
2690 return DIRECTIVE_FOUND;
2692 mmac_p = (MMacro **) hash_findi(&mmacros, spec.name, NULL);
2693 while (mmac_p && *mmac_p) {
2694 mmac = *mmac_p;
2695 if (mmac->casesense == spec.casesense &&
2696 !mstrcmp(mmac->name, spec.name, spec.casesense) &&
2697 mmac->nparam_min == spec.nparam_min &&
2698 mmac->nparam_max == spec.nparam_max &&
2699 mmac->plus == spec.plus) {
2700 *mmac_p = mmac->next;
2701 free_mmacro(mmac);
2702 } else {
2703 mmac_p = &mmac->next;
2706 free_tlist(origline);
2707 free_tlist(spec.dlist);
2708 return DIRECTIVE_FOUND;
2711 case PP_ROTATE:
2712 if (tline->next && tline->next->type == TOK_WHITESPACE)
2713 tline = tline->next;
2714 if (!tline->next) {
2715 free_tlist(origline);
2716 error(ERR_NONFATAL, "`%%rotate' missing rotate count");
2717 return DIRECTIVE_FOUND;
2719 t = expand_smacro(tline->next);
2720 tline->next = NULL;
2721 free_tlist(origline);
2722 tline = t;
2723 tptr = &t;
2724 tokval.t_type = TOKEN_INVALID;
2725 evalresult =
2726 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2727 free_tlist(tline);
2728 if (!evalresult)
2729 return DIRECTIVE_FOUND;
2730 if (tokval.t_type)
2731 error(ERR_WARNING|ERR_PASS1,
2732 "trailing garbage after expression ignored");
2733 if (!is_simple(evalresult)) {
2734 error(ERR_NONFATAL, "non-constant value given to `%%rotate'");
2735 return DIRECTIVE_FOUND;
2737 mmac = istk->mstk;
2738 while (mmac && !mmac->name) /* avoid mistaking %reps for macros */
2739 mmac = mmac->next_active;
2740 if (!mmac) {
2741 error(ERR_NONFATAL, "`%%rotate' invoked outside a macro call");
2742 } else if (mmac->nparam == 0) {
2743 error(ERR_NONFATAL,
2744 "`%%rotate' invoked within macro without parameters");
2745 } else {
2746 int rotate = mmac->rotate + reloc_value(evalresult);
2748 rotate %= (int)mmac->nparam;
2749 if (rotate < 0)
2750 rotate += mmac->nparam;
2752 mmac->rotate = rotate;
2754 return DIRECTIVE_FOUND;
2756 case PP_REP:
2757 nolist = false;
2758 do {
2759 tline = tline->next;
2760 } while (tok_type_(tline, TOK_WHITESPACE));
2762 if (tok_type_(tline, TOK_ID) &&
2763 nasm_stricmp(tline->text, ".nolist") == 0) {
2764 nolist = true;
2765 do {
2766 tline = tline->next;
2767 } while (tok_type_(tline, TOK_WHITESPACE));
2770 if (tline) {
2771 t = expand_smacro(tline);
2772 tptr = &t;
2773 tokval.t_type = TOKEN_INVALID;
2774 evalresult =
2775 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2776 if (!evalresult) {
2777 free_tlist(origline);
2778 return DIRECTIVE_FOUND;
2780 if (tokval.t_type)
2781 error(ERR_WARNING|ERR_PASS1,
2782 "trailing garbage after expression ignored");
2783 if (!is_simple(evalresult)) {
2784 error(ERR_NONFATAL, "non-constant value given to `%%rep'");
2785 return DIRECTIVE_FOUND;
2787 count = reloc_value(evalresult) + 1;
2788 } else {
2789 error(ERR_NONFATAL, "`%%rep' expects a repeat count");
2790 count = 0;
2792 free_tlist(origline);
2794 tmp_defining = defining;
2795 defining = nasm_malloc(sizeof(MMacro));
2796 defining->prev = NULL;
2797 defining->name = NULL; /* flags this macro as a %rep block */
2798 defining->casesense = false;
2799 defining->plus = false;
2800 defining->nolist = nolist;
2801 defining->in_progress = count;
2802 defining->max_depth = 0;
2803 defining->nparam_min = defining->nparam_max = 0;
2804 defining->defaults = NULL;
2805 defining->dlist = NULL;
2806 defining->expansion = NULL;
2807 defining->next_active = istk->mstk;
2808 defining->rep_nest = tmp_defining;
2809 return DIRECTIVE_FOUND;
2811 case PP_ENDREP:
2812 if (!defining || defining->name) {
2813 error(ERR_NONFATAL, "`%%endrep': no matching `%%rep'");
2814 return DIRECTIVE_FOUND;
2818 * Now we have a "macro" defined - although it has no name
2819 * and we won't be entering it in the hash tables - we must
2820 * push a macro-end marker for it on to istk->expansion.
2821 * After that, it will take care of propagating itself (a
2822 * macro-end marker line for a macro which is really a %rep
2823 * block will cause the macro to be re-expanded, complete
2824 * with another macro-end marker to ensure the process
2825 * continues) until the whole expansion is forcibly removed
2826 * from istk->expansion by a %exitrep.
2828 l = nasm_malloc(sizeof(Line));
2829 l->next = istk->expansion;
2830 l->finishes = defining;
2831 l->first = NULL;
2832 istk->expansion = l;
2834 istk->mstk = defining;
2836 list->uplevel(defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
2837 tmp_defining = defining;
2838 defining = defining->rep_nest;
2839 free_tlist(origline);
2840 return DIRECTIVE_FOUND;
2842 case PP_EXITREP:
2844 * We must search along istk->expansion until we hit a
2845 * macro-end marker for a macro with no name. Then we set
2846 * its `in_progress' flag to 0.
2848 for (l = istk->expansion; l; l = l->next)
2849 if (l->finishes && !l->finishes->name)
2850 break;
2852 if (l)
2853 l->finishes->in_progress = 1;
2854 else
2855 error(ERR_NONFATAL, "`%%exitrep' not within `%%rep' block");
2856 free_tlist(origline);
2857 return DIRECTIVE_FOUND;
2859 case PP_XDEFINE:
2860 case PP_IXDEFINE:
2861 case PP_DEFINE:
2862 case PP_IDEFINE:
2863 casesense = (i == PP_DEFINE || i == PP_XDEFINE);
2865 tline = tline->next;
2866 skip_white_(tline);
2867 tline = expand_id(tline);
2868 if (!tline || (tline->type != TOK_ID &&
2869 (tline->type != TOK_PREPROC_ID ||
2870 tline->text[1] != '$'))) {
2871 error(ERR_NONFATAL, "`%s' expects a macro identifier",
2872 pp_directives[i]);
2873 free_tlist(origline);
2874 return DIRECTIVE_FOUND;
2877 ctx = get_ctx(tline->text, &mname, false);
2878 last = tline;
2879 param_start = tline = tline->next;
2880 nparam = 0;
2882 /* Expand the macro definition now for %xdefine and %ixdefine */
2883 if ((i == PP_XDEFINE) || (i == PP_IXDEFINE))
2884 tline = expand_smacro(tline);
2886 if (tok_is_(tline, "(")) {
2888 * This macro has parameters.
2891 tline = tline->next;
2892 while (1) {
2893 skip_white_(tline);
2894 if (!tline) {
2895 error(ERR_NONFATAL, "parameter identifier expected");
2896 free_tlist(origline);
2897 return DIRECTIVE_FOUND;
2899 if (tline->type != TOK_ID) {
2900 error(ERR_NONFATAL,
2901 "`%s': parameter identifier expected",
2902 tline->text);
2903 free_tlist(origline);
2904 return DIRECTIVE_FOUND;
2906 tline->type = TOK_SMAC_PARAM + nparam++;
2907 tline = tline->next;
2908 skip_white_(tline);
2909 if (tok_is_(tline, ",")) {
2910 tline = tline->next;
2911 } else {
2912 if (!tok_is_(tline, ")")) {
2913 error(ERR_NONFATAL,
2914 "`)' expected to terminate macro template");
2915 free_tlist(origline);
2916 return DIRECTIVE_FOUND;
2918 break;
2921 last = tline;
2922 tline = tline->next;
2924 if (tok_type_(tline, TOK_WHITESPACE))
2925 last = tline, tline = tline->next;
2926 macro_start = NULL;
2927 last->next = NULL;
2928 t = tline;
2929 while (t) {
2930 if (t->type == TOK_ID) {
2931 for (tt = param_start; tt; tt = tt->next)
2932 if (tt->type >= TOK_SMAC_PARAM &&
2933 !strcmp(tt->text, t->text))
2934 t->type = tt->type;
2936 tt = t->next;
2937 t->next = macro_start;
2938 macro_start = t;
2939 t = tt;
2942 * Good. We now have a macro name, a parameter count, and a
2943 * token list (in reverse order) for an expansion. We ought
2944 * to be OK just to create an SMacro, store it, and let
2945 * free_tlist have the rest of the line (which we have
2946 * carefully re-terminated after chopping off the expansion
2947 * from the end).
2949 define_smacro(ctx, mname, casesense, nparam, macro_start);
2950 free_tlist(origline);
2951 return DIRECTIVE_FOUND;
2953 case PP_UNDEF:
2954 tline = tline->next;
2955 skip_white_(tline);
2956 tline = expand_id(tline);
2957 if (!tline || (tline->type != TOK_ID &&
2958 (tline->type != TOK_PREPROC_ID ||
2959 tline->text[1] != '$'))) {
2960 error(ERR_NONFATAL, "`%%undef' expects a macro identifier");
2961 free_tlist(origline);
2962 return DIRECTIVE_FOUND;
2964 if (tline->next) {
2965 error(ERR_WARNING|ERR_PASS1,
2966 "trailing garbage after macro name ignored");
2969 /* Find the context that symbol belongs to */
2970 ctx = get_ctx(tline->text, &mname, false);
2971 undef_smacro(ctx, mname);
2972 free_tlist(origline);
2973 return DIRECTIVE_FOUND;
2975 case PP_DEFSTR:
2976 case PP_IDEFSTR:
2977 casesense = (i == PP_DEFSTR);
2979 tline = tline->next;
2980 skip_white_(tline);
2981 tline = expand_id(tline);
2982 if (!tline || (tline->type != TOK_ID &&
2983 (tline->type != TOK_PREPROC_ID ||
2984 tline->text[1] != '$'))) {
2985 error(ERR_NONFATAL, "`%s' expects a macro identifier",
2986 pp_directives[i]);
2987 free_tlist(origline);
2988 return DIRECTIVE_FOUND;
2991 ctx = get_ctx(tline->text, &mname, false);
2992 last = tline;
2993 tline = expand_smacro(tline->next);
2994 last->next = NULL;
2996 while (tok_type_(tline, TOK_WHITESPACE))
2997 tline = delete_Token(tline);
2999 p = detoken(tline, false);
3000 macro_start = nasm_malloc(sizeof(*macro_start));
3001 macro_start->next = NULL;
3002 macro_start->text = nasm_quote(p, strlen(p));
3003 macro_start->type = TOK_STRING;
3004 macro_start->a.mac = NULL;
3005 nasm_free(p);
3008 * We now have a macro name, an implicit parameter count of
3009 * zero, and a string token to use as an expansion. Create
3010 * and store an SMacro.
3012 define_smacro(ctx, mname, casesense, 0, macro_start);
3013 free_tlist(origline);
3014 return DIRECTIVE_FOUND;
3016 case PP_DEFTOK:
3017 case PP_IDEFTOK:
3018 casesense = (i == PP_DEFTOK);
3020 tline = tline->next;
3021 skip_white_(tline);
3022 tline = expand_id(tline);
3023 if (!tline || (tline->type != TOK_ID &&
3024 (tline->type != TOK_PREPROC_ID ||
3025 tline->text[1] != '$'))) {
3026 error(ERR_NONFATAL,
3027 "`%s' expects a macro identifier as first parameter",
3028 pp_directives[i]);
3029 free_tlist(origline);
3030 return DIRECTIVE_FOUND;
3032 ctx = get_ctx(tline->text, &mname, false);
3033 last = tline;
3034 tline = expand_smacro(tline->next);
3035 last->next = NULL;
3037 t = tline;
3038 while (tok_type_(t, TOK_WHITESPACE))
3039 t = t->next;
3040 /* t should now point to the string */
3041 if (t->type != TOK_STRING) {
3042 error(ERR_NONFATAL,
3043 "`%s` requires string as second parameter",
3044 pp_directives[i]);
3045 free_tlist(tline);
3046 free_tlist(origline);
3047 return DIRECTIVE_FOUND;
3050 nasm_unquote_cstr(t->text, i);
3051 macro_start = tokenize(t->text);
3054 * We now have a macro name, an implicit parameter count of
3055 * zero, and a numeric token to use as an expansion. Create
3056 * and store an SMacro.
3058 define_smacro(ctx, mname, casesense, 0, macro_start);
3059 free_tlist(tline);
3060 free_tlist(origline);
3061 return DIRECTIVE_FOUND;
3063 case PP_PATHSEARCH:
3065 FILE *fp;
3066 StrList *xsl = NULL;
3067 StrList **xst = &xsl;
3069 casesense = true;
3071 tline = tline->next;
3072 skip_white_(tline);
3073 tline = expand_id(tline);
3074 if (!tline || (tline->type != TOK_ID &&
3075 (tline->type != TOK_PREPROC_ID ||
3076 tline->text[1] != '$'))) {
3077 error(ERR_NONFATAL,
3078 "`%%pathsearch' expects a macro identifier as first parameter");
3079 free_tlist(origline);
3080 return DIRECTIVE_FOUND;
3082 ctx = get_ctx(tline->text, &mname, false);
3083 last = tline;
3084 tline = expand_smacro(tline->next);
3085 last->next = NULL;
3087 t = tline;
3088 while (tok_type_(t, TOK_WHITESPACE))
3089 t = t->next;
3091 if (!t || (t->type != TOK_STRING &&
3092 t->type != TOK_INTERNAL_STRING)) {
3093 error(ERR_NONFATAL, "`%%pathsearch' expects a file name");
3094 free_tlist(tline);
3095 free_tlist(origline);
3096 return DIRECTIVE_FOUND; /* but we did _something_ */
3098 if (t->next)
3099 error(ERR_WARNING|ERR_PASS1,
3100 "trailing garbage after `%%pathsearch' ignored");
3101 p = t->text;
3102 if (t->type != TOK_INTERNAL_STRING)
3103 nasm_unquote(p, NULL);
3105 fp = inc_fopen(p, &xsl, &xst, true);
3106 if (fp) {
3107 p = xsl->str;
3108 fclose(fp); /* Don't actually care about the file */
3110 macro_start = nasm_malloc(sizeof(*macro_start));
3111 macro_start->next = NULL;
3112 macro_start->text = nasm_quote(p, strlen(p));
3113 macro_start->type = TOK_STRING;
3114 macro_start->a.mac = NULL;
3115 if (xsl)
3116 nasm_free(xsl);
3119 * We now have a macro name, an implicit parameter count of
3120 * zero, and a string token to use as an expansion. Create
3121 * and store an SMacro.
3123 define_smacro(ctx, mname, casesense, 0, macro_start);
3124 free_tlist(tline);
3125 free_tlist(origline);
3126 return DIRECTIVE_FOUND;
3129 case PP_STRLEN:
3130 casesense = true;
3132 tline = tline->next;
3133 skip_white_(tline);
3134 tline = expand_id(tline);
3135 if (!tline || (tline->type != TOK_ID &&
3136 (tline->type != TOK_PREPROC_ID ||
3137 tline->text[1] != '$'))) {
3138 error(ERR_NONFATAL,
3139 "`%%strlen' expects a macro identifier as first parameter");
3140 free_tlist(origline);
3141 return DIRECTIVE_FOUND;
3143 ctx = get_ctx(tline->text, &mname, false);
3144 last = tline;
3145 tline = expand_smacro(tline->next);
3146 last->next = NULL;
3148 t = tline;
3149 while (tok_type_(t, TOK_WHITESPACE))
3150 t = t->next;
3151 /* t should now point to the string */
3152 if (t->type != TOK_STRING) {
3153 error(ERR_NONFATAL,
3154 "`%%strlen` requires string as second parameter");
3155 free_tlist(tline);
3156 free_tlist(origline);
3157 return DIRECTIVE_FOUND;
3160 macro_start = nasm_malloc(sizeof(*macro_start));
3161 macro_start->next = NULL;
3162 make_tok_num(macro_start, nasm_unquote(t->text, NULL));
3163 macro_start->a.mac = NULL;
3166 * We now have a macro name, an implicit parameter count of
3167 * zero, and a numeric token to use as an expansion. Create
3168 * and store an SMacro.
3170 define_smacro(ctx, mname, casesense, 0, macro_start);
3171 free_tlist(tline);
3172 free_tlist(origline);
3173 return DIRECTIVE_FOUND;
3175 case PP_STRCAT:
3176 casesense = true;
3178 tline = tline->next;
3179 skip_white_(tline);
3180 tline = expand_id(tline);
3181 if (!tline || (tline->type != TOK_ID &&
3182 (tline->type != TOK_PREPROC_ID ||
3183 tline->text[1] != '$'))) {
3184 error(ERR_NONFATAL,
3185 "`%%strcat' expects a macro identifier as first parameter");
3186 free_tlist(origline);
3187 return DIRECTIVE_FOUND;
3189 ctx = get_ctx(tline->text, &mname, false);
3190 last = tline;
3191 tline = expand_smacro(tline->next);
3192 last->next = NULL;
3194 len = 0;
3195 for (t = tline; t; t = t->next) {
3196 switch (t->type) {
3197 case TOK_WHITESPACE:
3198 break;
3199 case TOK_STRING:
3200 len += t->a.len = nasm_unquote(t->text, NULL);
3201 break;
3202 case TOK_OTHER:
3203 if (!strcmp(t->text, ",")) /* permit comma separators */
3204 break;
3205 /* else fall through */
3206 default:
3207 error(ERR_NONFATAL,
3208 "non-string passed to `%%strcat' (%d)", t->type);
3209 free_tlist(tline);
3210 free_tlist(origline);
3211 return DIRECTIVE_FOUND;
3215 p = pp = nasm_malloc(len);
3216 t = tline;
3217 for (t = tline; t; t = t->next) {
3218 if (t->type == TOK_STRING) {
3219 memcpy(p, t->text, t->a.len);
3220 p += t->a.len;
3225 * We now have a macro name, an implicit parameter count of
3226 * zero, and a numeric token to use as an expansion. Create
3227 * and store an SMacro.
3229 macro_start = new_Token(NULL, TOK_STRING, NULL, 0);
3230 macro_start->text = nasm_quote(pp, len);
3231 nasm_free(pp);
3232 define_smacro(ctx, mname, casesense, 0, macro_start);
3233 free_tlist(tline);
3234 free_tlist(origline);
3235 return DIRECTIVE_FOUND;
3237 case PP_SUBSTR:
3239 int64_t a1, a2;
3240 size_t len;
3242 casesense = true;
3244 tline = tline->next;
3245 skip_white_(tline);
3246 tline = expand_id(tline);
3247 if (!tline || (tline->type != TOK_ID &&
3248 (tline->type != TOK_PREPROC_ID ||
3249 tline->text[1] != '$'))) {
3250 error(ERR_NONFATAL,
3251 "`%%substr' expects a macro identifier as first parameter");
3252 free_tlist(origline);
3253 return DIRECTIVE_FOUND;
3255 ctx = get_ctx(tline->text, &mname, false);
3256 last = tline;
3257 tline = expand_smacro(tline->next);
3258 last->next = NULL;
3260 t = tline->next;
3261 while (tok_type_(t, TOK_WHITESPACE))
3262 t = t->next;
3264 /* t should now point to the string */
3265 if (t->type != TOK_STRING) {
3266 error(ERR_NONFATAL,
3267 "`%%substr` requires string as second parameter");
3268 free_tlist(tline);
3269 free_tlist(origline);
3270 return DIRECTIVE_FOUND;
3273 tt = t->next;
3274 tptr = &tt;
3275 tokval.t_type = TOKEN_INVALID;
3276 evalresult = evaluate(ppscan, tptr, &tokval, NULL,
3277 pass, error, NULL);
3278 if (!evalresult) {
3279 free_tlist(tline);
3280 free_tlist(origline);
3281 return DIRECTIVE_FOUND;
3282 } else if (!is_simple(evalresult)) {
3283 error(ERR_NONFATAL, "non-constant value given to `%%substr`");
3284 free_tlist(tline);
3285 free_tlist(origline);
3286 return DIRECTIVE_FOUND;
3288 a1 = evalresult->value-1;
3290 while (tok_type_(tt, TOK_WHITESPACE))
3291 tt = tt->next;
3292 if (!tt) {
3293 a2 = 1; /* Backwards compatibility: one character */
3294 } else {
3295 tokval.t_type = TOKEN_INVALID;
3296 evalresult = evaluate(ppscan, tptr, &tokval, NULL,
3297 pass, error, NULL);
3298 if (!evalresult) {
3299 free_tlist(tline);
3300 free_tlist(origline);
3301 return DIRECTIVE_FOUND;
3302 } else if (!is_simple(evalresult)) {
3303 error(ERR_NONFATAL, "non-constant value given to `%%substr`");
3304 free_tlist(tline);
3305 free_tlist(origline);
3306 return DIRECTIVE_FOUND;
3308 a2 = evalresult->value;
3311 len = nasm_unquote(t->text, NULL);
3312 if (a2 < 0)
3313 a2 = a2+1+len-a1;
3314 if (a1+a2 > (int64_t)len)
3315 a2 = len-a1;
3317 macro_start = nasm_malloc(sizeof(*macro_start));
3318 macro_start->next = NULL;
3319 macro_start->text = nasm_quote((a1 < 0) ? "" : t->text+a1, a2);
3320 macro_start->type = TOK_STRING;
3321 macro_start->a.mac = NULL;
3324 * We now have a macro name, an implicit parameter count of
3325 * zero, and a numeric token to use as an expansion. Create
3326 * and store an SMacro.
3328 define_smacro(ctx, mname, casesense, 0, macro_start);
3329 free_tlist(tline);
3330 free_tlist(origline);
3331 return DIRECTIVE_FOUND;
3334 case PP_ASSIGN:
3335 case PP_IASSIGN:
3336 casesense = (i == PP_ASSIGN);
3338 tline = tline->next;
3339 skip_white_(tline);
3340 tline = expand_id(tline);
3341 if (!tline || (tline->type != TOK_ID &&
3342 (tline->type != TOK_PREPROC_ID ||
3343 tline->text[1] != '$'))) {
3344 error(ERR_NONFATAL,
3345 "`%%%sassign' expects a macro identifier",
3346 (i == PP_IASSIGN ? "i" : ""));
3347 free_tlist(origline);
3348 return DIRECTIVE_FOUND;
3350 ctx = get_ctx(tline->text, &mname, false);
3351 last = tline;
3352 tline = expand_smacro(tline->next);
3353 last->next = NULL;
3355 t = tline;
3356 tptr = &t;
3357 tokval.t_type = TOKEN_INVALID;
3358 evalresult =
3359 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
3360 free_tlist(tline);
3361 if (!evalresult) {
3362 free_tlist(origline);
3363 return DIRECTIVE_FOUND;
3366 if (tokval.t_type)
3367 error(ERR_WARNING|ERR_PASS1,
3368 "trailing garbage after expression ignored");
3370 if (!is_simple(evalresult)) {
3371 error(ERR_NONFATAL,
3372 "non-constant value given to `%%%sassign'",
3373 (i == PP_IASSIGN ? "i" : ""));
3374 free_tlist(origline);
3375 return DIRECTIVE_FOUND;
3378 macro_start = nasm_malloc(sizeof(*macro_start));
3379 macro_start->next = NULL;
3380 make_tok_num(macro_start, reloc_value(evalresult));
3381 macro_start->a.mac = NULL;
3384 * We now have a macro name, an implicit parameter count of
3385 * zero, and a numeric token to use as an expansion. Create
3386 * and store an SMacro.
3388 define_smacro(ctx, mname, casesense, 0, macro_start);
3389 free_tlist(origline);
3390 return DIRECTIVE_FOUND;
3392 case PP_LINE:
3394 * Syntax is `%line nnn[+mmm] [filename]'
3396 tline = tline->next;
3397 skip_white_(tline);
3398 if (!tok_type_(tline, TOK_NUMBER)) {
3399 error(ERR_NONFATAL, "`%%line' expects line number");
3400 free_tlist(origline);
3401 return DIRECTIVE_FOUND;
3403 k = readnum(tline->text, &err);
3404 m = 1;
3405 tline = tline->next;
3406 if (tok_is_(tline, "+")) {
3407 tline = tline->next;
3408 if (!tok_type_(tline, TOK_NUMBER)) {
3409 error(ERR_NONFATAL, "`%%line' expects line increment");
3410 free_tlist(origline);
3411 return DIRECTIVE_FOUND;
3413 m = readnum(tline->text, &err);
3414 tline = tline->next;
3416 skip_white_(tline);
3417 src_set_linnum(k);
3418 istk->lineinc = m;
3419 if (tline) {
3420 nasm_free(src_set_fname(detoken(tline, false)));
3422 free_tlist(origline);
3423 return DIRECTIVE_FOUND;
3425 default:
3426 error(ERR_FATAL,
3427 "preprocessor directive `%s' not yet implemented",
3428 pp_directives[i]);
3429 return DIRECTIVE_FOUND;
3434 * Ensure that a macro parameter contains a condition code and
3435 * nothing else. Return the condition code index if so, or -1
3436 * otherwise.
3438 static int find_cc(Token * t)
3440 Token *tt;
3441 int i, j, k, m;
3443 if (!t)
3444 return -1; /* Probably a %+ without a space */
3446 skip_white_(t);
3447 if (t->type != TOK_ID)
3448 return -1;
3449 tt = t->next;
3450 skip_white_(tt);
3451 if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
3452 return -1;
3454 i = -1;
3455 j = elements(conditions);
3456 while (j - i > 1) {
3457 k = (j + i) / 2;
3458 m = nasm_stricmp(t->text, conditions[k]);
3459 if (m == 0) {
3460 i = k;
3461 j = -2;
3462 break;
3463 } else if (m < 0) {
3464 j = k;
3465 } else
3466 i = k;
3468 if (j != -2)
3469 return -1;
3470 return i;
3473 static bool paste_tokens(Token **head, bool handle_paste_tokens)
3475 Token **tail, *t, *tt;
3476 Token **paste_head;
3477 bool did_paste = false;
3478 char *tmp;
3480 /* Now handle token pasting... */
3481 paste_head = NULL;
3482 tail = head;
3483 while ((t = *tail) && (tt = t->next)) {
3484 switch (t->type) {
3485 case TOK_WHITESPACE:
3486 if (tt->type == TOK_WHITESPACE) {
3487 /* Zap adjacent whitespace tokens */
3488 t->next = delete_Token(tt);
3489 } else {
3490 /* Do not advance paste_head here */
3491 tail = &t->next;
3493 break;
3494 case TOK_ID:
3495 case TOK_PREPROC_ID:
3496 case TOK_NUMBER:
3497 case TOK_FLOAT:
3499 size_t len = 0;
3500 char *tmp, *p;
3502 while (tt && (tt->type == TOK_ID || tt->type == TOK_PREPROC_ID ||
3503 tt->type == TOK_NUMBER || tt->type == TOK_FLOAT ||
3504 tt->type == TOK_OTHER)) {
3505 len += strlen(tt->text);
3506 tt = tt->next;
3509 /* Now tt points to the first token after the potential
3510 paste area... */
3511 if (tt != t->next) {
3512 /* We have at least two tokens... */
3513 len += strlen(t->text);
3514 p = tmp = nasm_malloc(len+1);
3516 while (t != tt) {
3517 strcpy(p, t->text);
3518 p = strchr(p, '\0');
3519 t = delete_Token(t);
3522 t = *tail = tokenize(tmp);
3523 nasm_free(tmp);
3525 while (t->next) {
3526 tail = &t->next;
3527 t = t->next;
3529 t->next = tt; /* Attach the remaining token chain */
3531 did_paste = true;
3533 paste_head = tail;
3534 tail = &t->next;
3535 break;
3537 case TOK_PASTE: /* %+ */
3538 if (handle_paste_tokens) {
3539 /* Zap %+ and whitespace tokens to the right */
3540 while (t && (t->type == TOK_WHITESPACE ||
3541 t->type == TOK_PASTE))
3542 t = *tail = delete_Token(t);
3543 if (!paste_head || !t)
3544 break; /* Nothing to paste with */
3545 tail = paste_head;
3546 t = *tail;
3547 tt = t->next;
3548 while (tok_type_(tt, TOK_WHITESPACE))
3549 tt = t->next = delete_Token(tt);
3551 if (tt) {
3552 tmp = nasm_strcat(t->text, tt->text);
3553 delete_Token(t);
3554 tt = delete_Token(tt);
3555 t = *tail = tokenize(tmp);
3556 nasm_free(tmp);
3557 while (t->next) {
3558 tail = &t->next;
3559 t = t->next;
3561 t->next = tt; /* Attach the remaining token chain */
3562 did_paste = true;
3564 paste_head = tail;
3565 tail = &t->next;
3566 break;
3568 /* else fall through */
3569 default:
3570 tail = paste_head = &t->next;
3571 break;
3574 return did_paste;
3577 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3578 * %-n) and MMacro-local identifiers (%%foo) as well as
3579 * macro indirection (%[...]).
3581 static Token *expand_mmac_params(Token * tline)
3583 Token *t, *tt, **tail, *thead;
3584 bool changed = false;
3586 tail = &thead;
3587 thead = NULL;
3589 while (tline) {
3590 if (tline->type == TOK_PREPROC_ID &&
3591 (((tline->text[1] == '+' || tline->text[1] == '-')
3592 && tline->text[2]) || tline->text[1] == '%'
3593 || (tline->text[1] >= '0' && tline->text[1] <= '9'))) {
3594 char *text = NULL;
3595 int type = 0, cc; /* type = 0 to placate optimisers */
3596 char tmpbuf[30];
3597 unsigned int n;
3598 int i;
3599 MMacro *mac;
3601 t = tline;
3602 tline = tline->next;
3604 mac = istk->mstk;
3605 while (mac && !mac->name) /* avoid mistaking %reps for macros */
3606 mac = mac->next_active;
3607 if (!mac)
3608 error(ERR_NONFATAL, "`%s': not in a macro call", t->text);
3609 else
3610 switch (t->text[1]) {
3612 * We have to make a substitution of one of the
3613 * forms %1, %-1, %+1, %%foo, %0.
3615 case '0':
3616 type = TOK_NUMBER;
3617 snprintf(tmpbuf, sizeof(tmpbuf), "%d", mac->nparam);
3618 text = nasm_strdup(tmpbuf);
3619 break;
3620 case '%':
3621 type = TOK_ID;
3622 snprintf(tmpbuf, sizeof(tmpbuf), "..@%"PRIu64".",
3623 mac->unique);
3624 text = nasm_strcat(tmpbuf, t->text + 2);
3625 break;
3626 case '-':
3627 n = atoi(t->text + 2) - 1;
3628 if (n >= mac->nparam)
3629 tt = NULL;
3630 else {
3631 if (mac->nparam > 1)
3632 n = (n + mac->rotate) % mac->nparam;
3633 tt = mac->params[n];
3635 cc = find_cc(tt);
3636 if (cc == -1) {
3637 error(ERR_NONFATAL,
3638 "macro parameter %d is not a condition code",
3639 n + 1);
3640 text = NULL;
3641 } else {
3642 type = TOK_ID;
3643 if (inverse_ccs[cc] == -1) {
3644 error(ERR_NONFATAL,
3645 "condition code `%s' is not invertible",
3646 conditions[cc]);
3647 text = NULL;
3648 } else
3649 text = nasm_strdup(conditions[inverse_ccs[cc]]);
3651 break;
3652 case '+':
3653 n = atoi(t->text + 2) - 1;
3654 if (n >= mac->nparam)
3655 tt = NULL;
3656 else {
3657 if (mac->nparam > 1)
3658 n = (n + mac->rotate) % mac->nparam;
3659 tt = mac->params[n];
3661 cc = find_cc(tt);
3662 if (cc == -1) {
3663 error(ERR_NONFATAL,
3664 "macro parameter %d is not a condition code",
3665 n + 1);
3666 text = NULL;
3667 } else {
3668 type = TOK_ID;
3669 text = nasm_strdup(conditions[cc]);
3671 break;
3672 default:
3673 n = atoi(t->text + 1) - 1;
3674 if (n >= mac->nparam)
3675 tt = NULL;
3676 else {
3677 if (mac->nparam > 1)
3678 n = (n + mac->rotate) % mac->nparam;
3679 tt = mac->params[n];
3681 if (tt) {
3682 for (i = 0; i < mac->paramlen[n]; i++) {
3683 *tail = new_Token(NULL, tt->type, tt->text, 0);
3684 tail = &(*tail)->next;
3685 tt = tt->next;
3688 text = NULL; /* we've done it here */
3689 break;
3691 if (!text) {
3692 delete_Token(t);
3693 } else {
3694 *tail = t;
3695 tail = &t->next;
3696 t->type = type;
3697 nasm_free(t->text);
3698 t->text = text;
3699 t->a.mac = NULL;
3701 changed = true;
3702 continue;
3703 } else if (tline->type == TOK_INDIRECT) {
3704 t = tline;
3705 tline = tline->next;
3706 tt = tokenize(t->text);
3707 tt = expand_mmac_params(tt);
3708 tt = expand_smacro(tt);
3709 *tail = tt;
3710 while (tt) {
3711 tt->a.mac = NULL; /* Necessary? */
3712 tail = &tt->next;
3713 tt = tt->next;
3715 delete_Token(t);
3716 changed = true;
3717 } else {
3718 t = *tail = tline;
3719 tline = tline->next;
3720 t->a.mac = NULL;
3721 tail = &t->next;
3724 *tail = NULL;
3726 if (changed)
3727 paste_tokens(&thead, false);
3729 return thead;
3733 * Expand all single-line macro calls made in the given line.
3734 * Return the expanded version of the line. The original is deemed
3735 * to be destroyed in the process. (In reality we'll just move
3736 * Tokens from input to output a lot of the time, rather than
3737 * actually bothering to destroy and replicate.)
3740 static Token *expand_smacro(Token * tline)
3742 Token *t, *tt, *mstart, **tail, *thead;
3743 struct hash_table *smtbl;
3744 SMacro *head = NULL, *m;
3745 Token **params;
3746 int *paramsize;
3747 unsigned int nparam, sparam;
3748 int brackets;
3749 Token *org_tline = tline;
3750 Context *ctx;
3751 const char *mname;
3752 int deadman = DEADMAN_LIMIT;
3753 bool expanded;
3756 * Trick: we should avoid changing the start token pointer since it can
3757 * be contained in "next" field of other token. Because of this
3758 * we allocate a copy of first token and work with it; at the end of
3759 * routine we copy it back
3761 if (org_tline) {
3762 tline =
3763 new_Token(org_tline->next, org_tline->type, org_tline->text,
3765 tline->a.mac = org_tline->a.mac;
3766 nasm_free(org_tline->text);
3767 org_tline->text = NULL;
3770 expanded = true; /* Always expand %+ at least once */
3772 again:
3773 tail = &thead;
3774 thead = NULL;
3776 while (tline) { /* main token loop */
3777 if (!--deadman) {
3778 error(ERR_NONFATAL, "interminable macro recursion");
3779 break;
3782 if ((mname = tline->text)) {
3783 /* if this token is a local macro, look in local context */
3784 if (tline->type == TOK_ID || tline->type == TOK_PREPROC_ID)
3785 ctx = get_ctx(mname, &mname, true);
3786 else
3787 ctx = NULL;
3788 smtbl = ctx ? &ctx->localmac : &smacros;
3789 head = (SMacro *) hash_findix(smtbl, mname);
3792 * We've hit an identifier. As in is_mmacro below, we first
3793 * check whether the identifier is a single-line macro at
3794 * all, then think about checking for parameters if
3795 * necessary.
3797 for (m = head; m; m = m->next)
3798 if (!mstrcmp(m->name, mname, m->casesense))
3799 break;
3800 if (m) {
3801 mstart = tline;
3802 params = NULL;
3803 paramsize = NULL;
3804 if (m->nparam == 0) {
3806 * Simple case: the macro is parameterless. Discard the
3807 * one token that the macro call took, and push the
3808 * expansion back on the to-do stack.
3810 if (!m->expansion) {
3811 if (!strcmp("__FILE__", m->name)) {
3812 int32_t num = 0;
3813 char *file = NULL;
3814 src_get(&num, &file);
3815 tline->text = nasm_quote(file, strlen(file));
3816 tline->type = TOK_STRING;
3817 nasm_free(file);
3818 continue;
3820 if (!strcmp("__LINE__", m->name)) {
3821 nasm_free(tline->text);
3822 make_tok_num(tline, src_get_linnum());
3823 continue;
3825 if (!strcmp("__BITS__", m->name)) {
3826 nasm_free(tline->text);
3827 make_tok_num(tline, globalbits);
3828 continue;
3830 tline = delete_Token(tline);
3831 continue;
3833 } else {
3835 * Complicated case: at least one macro with this name
3836 * exists and takes parameters. We must find the
3837 * parameters in the call, count them, find the SMacro
3838 * that corresponds to that form of the macro call, and
3839 * substitute for the parameters when we expand. What a
3840 * pain.
3842 /*tline = tline->next;
3843 skip_white_(tline); */
3844 do {
3845 t = tline->next;
3846 while (tok_type_(t, TOK_SMAC_END)) {
3847 t->a.mac->in_progress = false;
3848 t->text = NULL;
3849 t = tline->next = delete_Token(t);
3851 tline = t;
3852 } while (tok_type_(tline, TOK_WHITESPACE));
3853 if (!tok_is_(tline, "(")) {
3855 * This macro wasn't called with parameters: ignore
3856 * the call. (Behaviour borrowed from gnu cpp.)
3858 tline = mstart;
3859 m = NULL;
3860 } else {
3861 int paren = 0;
3862 int white = 0;
3863 brackets = 0;
3864 nparam = 0;
3865 sparam = PARAM_DELTA;
3866 params = nasm_malloc(sparam * sizeof(Token *));
3867 params[0] = tline->next;
3868 paramsize = nasm_malloc(sparam * sizeof(int));
3869 paramsize[0] = 0;
3870 while (true) { /* parameter loop */
3872 * For some unusual expansions
3873 * which concatenates function call
3875 t = tline->next;
3876 while (tok_type_(t, TOK_SMAC_END)) {
3877 t->a.mac->in_progress = false;
3878 t->text = NULL;
3879 t = tline->next = delete_Token(t);
3881 tline = t;
3883 if (!tline) {
3884 error(ERR_NONFATAL,
3885 "macro call expects terminating `)'");
3886 break;
3888 if (tline->type == TOK_WHITESPACE
3889 && brackets <= 0) {
3890 if (paramsize[nparam])
3891 white++;
3892 else
3893 params[nparam] = tline->next;
3894 continue; /* parameter loop */
3896 if (tline->type == TOK_OTHER
3897 && tline->text[1] == 0) {
3898 char ch = tline->text[0];
3899 if (ch == ',' && !paren && brackets <= 0) {
3900 if (++nparam >= sparam) {
3901 sparam += PARAM_DELTA;
3902 params = nasm_realloc(params,
3903 sparam *
3904 sizeof(Token
3905 *));
3906 paramsize =
3907 nasm_realloc(paramsize,
3908 sparam *
3909 sizeof(int));
3911 params[nparam] = tline->next;
3912 paramsize[nparam] = 0;
3913 white = 0;
3914 continue; /* parameter loop */
3916 if (ch == '{' &&
3917 (brackets > 0 || (brackets == 0 &&
3918 !paramsize[nparam])))
3920 if (!(brackets++)) {
3921 params[nparam] = tline->next;
3922 continue; /* parameter loop */
3925 if (ch == '}' && brackets > 0)
3926 if (--brackets == 0) {
3927 brackets = -1;
3928 continue; /* parameter loop */
3930 if (ch == '(' && !brackets)
3931 paren++;
3932 if (ch == ')' && brackets <= 0)
3933 if (--paren < 0)
3934 break;
3936 if (brackets < 0) {
3937 brackets = 0;
3938 error(ERR_NONFATAL, "braces do not "
3939 "enclose all of macro parameter");
3941 paramsize[nparam] += white + 1;
3942 white = 0;
3943 } /* parameter loop */
3944 nparam++;
3945 while (m && (m->nparam != nparam ||
3946 mstrcmp(m->name, mname,
3947 m->casesense)))
3948 m = m->next;
3949 if (!m)
3950 error(ERR_WARNING|ERR_PASS1|ERR_WARN_MNP,
3951 "macro `%s' exists, "
3952 "but not taking %d parameters",
3953 mstart->text, nparam);
3956 if (m && m->in_progress)
3957 m = NULL;
3958 if (!m) { /* in progess or didn't find '(' or wrong nparam */
3960 * Design question: should we handle !tline, which
3961 * indicates missing ')' here, or expand those
3962 * macros anyway, which requires the (t) test a few
3963 * lines down?
3965 nasm_free(params);
3966 nasm_free(paramsize);
3967 tline = mstart;
3968 } else {
3970 * Expand the macro: we are placed on the last token of the
3971 * call, so that we can easily split the call from the
3972 * following tokens. We also start by pushing an SMAC_END
3973 * token for the cycle removal.
3975 t = tline;
3976 if (t) {
3977 tline = t->next;
3978 t->next = NULL;
3980 tt = new_Token(tline, TOK_SMAC_END, NULL, 0);
3981 tt->a.mac = m;
3982 m->in_progress = true;
3983 tline = tt;
3984 for (t = m->expansion; t; t = t->next) {
3985 if (t->type >= TOK_SMAC_PARAM) {
3986 Token *pcopy = tline, **ptail = &pcopy;
3987 Token *ttt, *pt;
3988 int i;
3990 ttt = params[t->type - TOK_SMAC_PARAM];
3991 for (i = paramsize[t->type - TOK_SMAC_PARAM];
3992 --i >= 0;) {
3993 pt = *ptail =
3994 new_Token(tline, ttt->type, ttt->text,
3996 ptail = &pt->next;
3997 ttt = ttt->next;
3999 tline = pcopy;
4000 } else if (t->type == TOK_PREPROC_Q) {
4001 tt = new_Token(tline, TOK_ID, mname, 0);
4002 tline = tt;
4003 } else if (t->type == TOK_PREPROC_QQ) {
4004 tt = new_Token(tline, TOK_ID, m->name, 0);
4005 tline = tt;
4006 } else {
4007 tt = new_Token(tline, t->type, t->text, 0);
4008 tline = tt;
4013 * Having done that, get rid of the macro call, and clean
4014 * up the parameters.
4016 nasm_free(params);
4017 nasm_free(paramsize);
4018 free_tlist(mstart);
4019 expanded = true;
4020 continue; /* main token loop */
4025 if (tline->type == TOK_SMAC_END) {
4026 tline->a.mac->in_progress = false;
4027 tline = delete_Token(tline);
4028 } else {
4029 t = *tail = tline;
4030 tline = tline->next;
4031 t->a.mac = NULL;
4032 t->next = NULL;
4033 tail = &t->next;
4038 * Now scan the entire line and look for successive TOK_IDs that resulted
4039 * after expansion (they can't be produced by tokenize()). The successive
4040 * TOK_IDs should be concatenated.
4041 * Also we look for %+ tokens and concatenate the tokens before and after
4042 * them (without white spaces in between).
4044 if (expanded && paste_tokens(&thead, true)) {
4046 * If we concatenated something, *and* we had previously expanded
4047 * an actual macro, scan the lines again for macros...
4049 tline = thead;
4050 expanded = false;
4051 goto again;
4054 if (org_tline) {
4055 if (thead) {
4056 *org_tline = *thead;
4057 /* since we just gave text to org_line, don't free it */
4058 thead->text = NULL;
4059 delete_Token(thead);
4060 } else {
4061 /* the expression expanded to empty line;
4062 we can't return NULL for some reasons
4063 we just set the line to a single WHITESPACE token. */
4064 memset(org_tline, 0, sizeof(*org_tline));
4065 org_tline->text = NULL;
4066 org_tline->type = TOK_WHITESPACE;
4068 thead = org_tline;
4071 return thead;
4075 * Similar to expand_smacro but used exclusively with macro identifiers
4076 * right before they are fetched in. The reason is that there can be
4077 * identifiers consisting of several subparts. We consider that if there
4078 * are more than one element forming the name, user wants a expansion,
4079 * otherwise it will be left as-is. Example:
4081 * %define %$abc cde
4083 * the identifier %$abc will be left as-is so that the handler for %define
4084 * will suck it and define the corresponding value. Other case:
4086 * %define _%$abc cde
4088 * In this case user wants name to be expanded *before* %define starts
4089 * working, so we'll expand %$abc into something (if it has a value;
4090 * otherwise it will be left as-is) then concatenate all successive
4091 * PP_IDs into one.
4093 static Token *expand_id(Token * tline)
4095 Token *cur, *oldnext = NULL;
4097 if (!tline || !tline->next)
4098 return tline;
4100 cur = tline;
4101 while (cur->next &&
4102 (cur->next->type == TOK_ID ||
4103 cur->next->type == TOK_PREPROC_ID
4104 || cur->next->type == TOK_NUMBER))
4105 cur = cur->next;
4107 /* If identifier consists of just one token, don't expand */
4108 if (cur == tline)
4109 return tline;
4111 if (cur) {
4112 oldnext = cur->next; /* Detach the tail past identifier */
4113 cur->next = NULL; /* so that expand_smacro stops here */
4116 tline = expand_smacro(tline);
4118 if (cur) {
4119 /* expand_smacro possibly changhed tline; re-scan for EOL */
4120 cur = tline;
4121 while (cur && cur->next)
4122 cur = cur->next;
4123 if (cur)
4124 cur->next = oldnext;
4127 return tline;
4131 * Determine whether the given line constitutes a multi-line macro
4132 * call, and return the MMacro structure called if so. Doesn't have
4133 * to check for an initial label - that's taken care of in
4134 * expand_mmacro - but must check numbers of parameters. Guaranteed
4135 * to be called with tline->type == TOK_ID, so the putative macro
4136 * name is easy to find.
4138 static MMacro *is_mmacro(Token * tline, Token *** params_array)
4140 MMacro *head, *m;
4141 Token **params;
4142 int nparam;
4144 head = (MMacro *) hash_findix(&mmacros, tline->text);
4147 * Efficiency: first we see if any macro exists with the given
4148 * name. If not, we can return NULL immediately. _Then_ we
4149 * count the parameters, and then we look further along the
4150 * list if necessary to find the proper MMacro.
4152 for (m = head; m; m = m->next)
4153 if (!mstrcmp(m->name, tline->text, m->casesense))
4154 break;
4155 if (!m)
4156 return NULL;
4159 * OK, we have a potential macro. Count and demarcate the
4160 * parameters.
4162 count_mmac_params(tline->next, &nparam, &params);
4165 * So we know how many parameters we've got. Find the MMacro
4166 * structure that handles this number.
4168 while (m) {
4169 if (m->nparam_min <= nparam
4170 && (m->plus || nparam <= m->nparam_max)) {
4172 * This one is right. Just check if cycle removal
4173 * prohibits us using it before we actually celebrate...
4175 if (m->in_progress > m->max_depth) {
4176 if (m->max_depth > 0) {
4177 error(ERR_WARNING,
4178 "reached maximum recursion depth of %i",
4179 m->max_depth);
4181 nasm_free(params);
4182 return NULL;
4185 * It's right, and we can use it. Add its default
4186 * parameters to the end of our list if necessary.
4188 if (m->defaults && nparam < m->nparam_min + m->ndefs) {
4189 params =
4190 nasm_realloc(params,
4191 ((m->nparam_min + m->ndefs +
4192 1) * sizeof(*params)));
4193 while (nparam < m->nparam_min + m->ndefs) {
4194 params[nparam] = m->defaults[nparam - m->nparam_min];
4195 nparam++;
4199 * If we've gone over the maximum parameter count (and
4200 * we're in Plus mode), ignore parameters beyond
4201 * nparam_max.
4203 if (m->plus && nparam > m->nparam_max)
4204 nparam = m->nparam_max;
4206 * Then terminate the parameter list, and leave.
4208 if (!params) { /* need this special case */
4209 params = nasm_malloc(sizeof(*params));
4210 nparam = 0;
4212 params[nparam] = NULL;
4213 *params_array = params;
4214 return m;
4217 * This one wasn't right: look for the next one with the
4218 * same name.
4220 for (m = m->next; m; m = m->next)
4221 if (!mstrcmp(m->name, tline->text, m->casesense))
4222 break;
4226 * After all that, we didn't find one with the right number of
4227 * parameters. Issue a warning, and fail to expand the macro.
4229 error(ERR_WARNING|ERR_PASS1|ERR_WARN_MNP,
4230 "macro `%s' exists, but not taking %d parameters",
4231 tline->text, nparam);
4232 nasm_free(params);
4233 return NULL;
4238 * Save MMacro invocation specific fields in
4239 * preparation for a recursive macro expansion
4241 static void push_mmacro(MMacro *m)
4243 MMacroInvocation *i;
4245 i = nasm_malloc(sizeof(MMacroInvocation));
4246 i->prev = m->prev;
4247 i->params = m->params;
4248 i->iline = m->iline;
4249 i->nparam = m->nparam;
4250 i->rotate = m->rotate;
4251 i->paramlen = m->paramlen;
4252 i->unique = m->unique;
4253 m->prev = i;
4258 * Restore MMacro invocation specific fields that were
4259 * saved during a previous recursive macro expansion
4261 static void pop_mmacro(MMacro *m)
4263 MMacroInvocation *i;
4265 if (m->prev) {
4266 i = m->prev;
4267 m->prev = i->prev;
4268 m->params = i->params;
4269 m->iline = i->iline;
4270 m->nparam = i->nparam;
4271 m->rotate = i->rotate;
4272 m->paramlen = i->paramlen;
4273 m->unique = i->unique;
4274 nasm_free(i);
4280 * Expand the multi-line macro call made by the given line, if
4281 * there is one to be expanded. If there is, push the expansion on
4282 * istk->expansion and return 1. Otherwise return 0.
4284 static int expand_mmacro(Token * tline)
4286 Token *startline = tline;
4287 Token *label = NULL;
4288 int dont_prepend = 0;
4289 Token **params, *t, *mtok, *tt;
4290 MMacro *m;
4291 Line *l, *ll;
4292 int i, nparam, *paramlen;
4293 const char *mname;
4295 t = tline;
4296 skip_white_(t);
4297 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
4298 if (!tok_type_(t, TOK_ID) && !tok_type_(t, TOK_PREPROC_ID))
4299 return 0;
4300 mtok = t;
4301 m = is_mmacro(t, &params);
4302 if (m) {
4303 mname = t->text;
4304 } else {
4305 Token *last;
4307 * We have an id which isn't a macro call. We'll assume
4308 * it might be a label; we'll also check to see if a
4309 * colon follows it. Then, if there's another id after
4310 * that lot, we'll check it again for macro-hood.
4312 label = last = t;
4313 t = t->next;
4314 if (tok_type_(t, TOK_WHITESPACE))
4315 last = t, t = t->next;
4316 if (tok_is_(t, ":")) {
4317 dont_prepend = 1;
4318 last = t, t = t->next;
4319 if (tok_type_(t, TOK_WHITESPACE))
4320 last = t, t = t->next;
4322 if (!tok_type_(t, TOK_ID) || !(m = is_mmacro(t, &params)))
4323 return 0;
4324 last->next = NULL;
4325 mname = t->text;
4326 tline = t;
4330 * Fix up the parameters: this involves stripping leading and
4331 * trailing whitespace, then stripping braces if they are
4332 * present.
4334 for (nparam = 0; params[nparam]; nparam++) ;
4335 paramlen = nparam ? nasm_malloc(nparam * sizeof(*paramlen)) : NULL;
4337 for (i = 0; params[i]; i++) {
4338 int brace = false;
4339 int comma = (!m->plus || i < nparam - 1);
4341 t = params[i];
4342 skip_white_(t);
4343 if (tok_is_(t, "{"))
4344 t = t->next, brace = true, comma = false;
4345 params[i] = t;
4346 paramlen[i] = 0;
4347 while (t) {
4348 if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
4349 break; /* ... because we have hit a comma */
4350 if (comma && t->type == TOK_WHITESPACE
4351 && tok_is_(t->next, ","))
4352 break; /* ... or a space then a comma */
4353 if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
4354 break; /* ... or a brace */
4355 t = t->next;
4356 paramlen[i]++;
4361 * OK, we have a MMacro structure together with a set of
4362 * parameters. We must now go through the expansion and push
4363 * copies of each Line on to istk->expansion. Substitution of
4364 * parameter tokens and macro-local tokens doesn't get done
4365 * until the single-line macro substitution process; this is
4366 * because delaying them allows us to change the semantics
4367 * later through %rotate.
4369 * First, push an end marker on to istk->expansion, mark this
4370 * macro as in progress, and set up its invocation-specific
4371 * variables.
4373 ll = nasm_malloc(sizeof(Line));
4374 ll->next = istk->expansion;
4375 ll->finishes = m;
4376 ll->first = NULL;
4377 istk->expansion = ll;
4380 * Save the previous MMacro expansion in the case of
4381 * macro recursion
4383 if (m->max_depth && m->in_progress)
4384 push_mmacro(m);
4386 m->in_progress ++;
4387 m->params = params;
4388 m->iline = tline;
4389 m->nparam = nparam;
4390 m->rotate = 0;
4391 m->paramlen = paramlen;
4392 m->unique = unique++;
4393 m->lineno = 0;
4395 m->next_active = istk->mstk;
4396 istk->mstk = m;
4398 for (l = m->expansion; l; l = l->next) {
4399 Token **tail;
4401 ll = nasm_malloc(sizeof(Line));
4402 ll->finishes = NULL;
4403 ll->next = istk->expansion;
4404 istk->expansion = ll;
4405 tail = &ll->first;
4407 for (t = l->first; t; t = t->next) {
4408 Token *x = t;
4409 switch (t->type) {
4410 case TOK_PREPROC_Q:
4411 tt = *tail = new_Token(NULL, TOK_ID, mname, 0);
4412 break;
4413 case TOK_PREPROC_QQ:
4414 tt = *tail = new_Token(NULL, TOK_ID, m->name, 0);
4415 break;
4416 case TOK_PREPROC_ID:
4417 if (t->text[1] == '0' && t->text[2] == '0') {
4418 dont_prepend = -1;
4419 x = label;
4420 if (!x)
4421 continue;
4423 /* fall through */
4424 default:
4425 tt = *tail = new_Token(NULL, x->type, x->text, 0);
4426 break;
4428 tail = &tt->next;
4430 *tail = NULL;
4434 * If we had a label, push it on as the first line of
4435 * the macro expansion.
4437 if (label) {
4438 if (dont_prepend < 0)
4439 free_tlist(startline);
4440 else {
4441 ll = nasm_malloc(sizeof(Line));
4442 ll->finishes = NULL;
4443 ll->next = istk->expansion;
4444 istk->expansion = ll;
4445 ll->first = startline;
4446 if (!dont_prepend) {
4447 while (label->next)
4448 label = label->next;
4449 label->next = tt = new_Token(NULL, TOK_OTHER, ":", 0);
4454 list->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
4456 return 1;
4459 /* The function that actually does the error reporting */
4460 static void verror(int severity, const char *fmt, va_list arg)
4462 char buff[1024];
4464 vsnprintf(buff, sizeof(buff), fmt, arg);
4466 if (istk && istk->mstk && istk->mstk->name)
4467 _error(severity, "(%s:%d) %s", istk->mstk->name,
4468 istk->mstk->lineno, buff);
4469 else
4470 _error(severity, "%s", buff);
4474 * Since preprocessor always operate only on the line that didn't
4475 * arrived yet, we should always use ERR_OFFBY1.
4477 static void error(int severity, const char *fmt, ...)
4479 va_list arg;
4481 /* If we're in a dead branch of IF or something like it, ignore the error */
4482 if (istk && istk->conds && !emitting(istk->conds->state))
4483 return;
4485 va_start(arg, fmt);
4486 verror(severity, fmt, arg);
4487 va_end(arg);
4491 * Because %else etc are evaluated in the state context
4492 * of the previous branch, errors might get lost with error():
4493 * %if 0 ... %else trailing garbage ... %endif
4494 * So %else etc should report errors with this function.
4496 static void error_precond(int severity, const char *fmt, ...)
4498 va_list arg;
4500 /* Only ignore the error if it's really in a dead branch */
4501 if (istk && istk->conds && istk->conds->state == COND_NEVER)
4502 return;
4504 va_start(arg, fmt);
4505 verror(severity, fmt, arg);
4506 va_end(arg);
4509 static void
4510 pp_reset(char *file, int apass, efunc errfunc, evalfunc eval,
4511 ListGen * listgen, StrList **deplist)
4513 Token *t;
4515 _error = errfunc;
4516 cstk = NULL;
4517 istk = nasm_malloc(sizeof(Include));
4518 istk->next = NULL;
4519 istk->conds = NULL;
4520 istk->expansion = NULL;
4521 istk->mstk = NULL;
4522 istk->fp = fopen(file, "r");
4523 istk->fname = NULL;
4524 src_set_fname(nasm_strdup(file));
4525 src_set_linnum(0);
4526 istk->lineinc = 1;
4527 if (!istk->fp)
4528 error(ERR_FATAL|ERR_NOFILE, "unable to open input file `%s'",
4529 file);
4530 defining = NULL;
4531 nested_mac_count = 0;
4532 nested_rep_count = 0;
4533 init_macros();
4534 unique = 0;
4535 if (tasm_compatible_mode) {
4536 stdmacpos = nasm_stdmac;
4537 } else {
4538 stdmacpos = nasm_stdmac_after_tasm;
4540 any_extrastdmac = extrastdmac && *extrastdmac;
4541 do_predef = true;
4542 list = listgen;
4543 evaluate = eval;
4546 * 0 for dependencies, 1 for preparatory passes, 2 for final pass.
4547 * The caller, however, will also pass in 3 for preprocess-only so
4548 * we can set __PASS__ accordingly.
4550 pass = apass > 2 ? 2 : apass;
4552 dephead = deptail = deplist;
4553 if (deplist) {
4554 StrList *sl = nasm_malloc(strlen(file)+1+sizeof sl->next);
4555 sl->next = NULL;
4556 strcpy(sl->str, file);
4557 *deptail = sl;
4558 deptail = &sl->next;
4562 * Define the __PASS__ macro. This is defined here unlike
4563 * all the other builtins, because it is special -- it varies between
4564 * passes.
4566 t = nasm_malloc(sizeof(*t));
4567 t->next = NULL;
4568 make_tok_num(t, apass);
4569 t->a.mac = NULL;
4570 define_smacro(NULL, "__PASS__", true, 0, t);
4573 static char *pp_getline(void)
4575 char *line;
4576 Token *tline;
4578 while (1) {
4580 * Fetch a tokenized line, either from the macro-expansion
4581 * buffer or from the input file.
4583 tline = NULL;
4584 while (istk->expansion && istk->expansion->finishes) {
4585 Line *l = istk->expansion;
4586 if (!l->finishes->name && l->finishes->in_progress > 1) {
4587 Line *ll;
4590 * This is a macro-end marker for a macro with no
4591 * name, which means it's not really a macro at all
4592 * but a %rep block, and the `in_progress' field is
4593 * more than 1, meaning that we still need to
4594 * repeat. (1 means the natural last repetition; 0
4595 * means termination by %exitrep.) We have
4596 * therefore expanded up to the %endrep, and must
4597 * push the whole block on to the expansion buffer
4598 * again. We don't bother to remove the macro-end
4599 * marker: we'd only have to generate another one
4600 * if we did.
4602 l->finishes->in_progress--;
4603 for (l = l->finishes->expansion; l; l = l->next) {
4604 Token *t, *tt, **tail;
4606 ll = nasm_malloc(sizeof(Line));
4607 ll->next = istk->expansion;
4608 ll->finishes = NULL;
4609 ll->first = NULL;
4610 tail = &ll->first;
4612 for (t = l->first; t; t = t->next) {
4613 if (t->text || t->type == TOK_WHITESPACE) {
4614 tt = *tail =
4615 new_Token(NULL, t->type, t->text, 0);
4616 tail = &tt->next;
4620 istk->expansion = ll;
4622 } else {
4624 * Check whether a `%rep' was started and not ended
4625 * within this macro expansion. This can happen and
4626 * should be detected. It's a fatal error because
4627 * I'm too confused to work out how to recover
4628 * sensibly from it.
4630 if (defining) {
4631 if (defining->name)
4632 error(ERR_PANIC,
4633 "defining with name in expansion");
4634 else if (istk->mstk->name)
4635 error(ERR_FATAL,
4636 "`%%rep' without `%%endrep' within"
4637 " expansion of macro `%s'",
4638 istk->mstk->name);
4642 * FIXME: investigate the relationship at this point between
4643 * istk->mstk and l->finishes
4646 MMacro *m = istk->mstk;
4647 istk->mstk = m->next_active;
4648 if (m->name) {
4650 * This was a real macro call, not a %rep, and
4651 * therefore the parameter information needs to
4652 * be freed.
4654 if (m->prev) {
4655 pop_mmacro(m);
4656 l->finishes->in_progress --;
4657 } else {
4658 nasm_free(m->params);
4659 free_tlist(m->iline);
4660 nasm_free(m->paramlen);
4661 l->finishes->in_progress = 0;
4663 } else
4664 free_mmacro(m);
4666 istk->expansion = l->next;
4667 nasm_free(l);
4668 list->downlevel(LIST_MACRO);
4671 while (1) { /* until we get a line we can use */
4673 if (istk->expansion) { /* from a macro expansion */
4674 char *p;
4675 Line *l = istk->expansion;
4676 if (istk->mstk)
4677 istk->mstk->lineno++;
4678 tline = l->first;
4679 istk->expansion = l->next;
4680 nasm_free(l);
4681 p = detoken(tline, false);
4682 list->line(LIST_MACRO, p);
4683 nasm_free(p);
4684 break;
4686 line = read_line();
4687 if (line) { /* from the current input file */
4688 line = prepreproc(line);
4689 tline = tokenize(line);
4690 nasm_free(line);
4691 break;
4694 * The current file has ended; work down the istk
4697 Include *i = istk;
4698 fclose(i->fp);
4699 if (i->conds)
4700 error(ERR_FATAL,
4701 "expected `%%endif' before end of file");
4702 /* only set line and file name if there's a next node */
4703 if (i->next) {
4704 src_set_linnum(i->lineno);
4705 nasm_free(src_set_fname(i->fname));
4707 istk = i->next;
4708 list->downlevel(LIST_INCLUDE);
4709 nasm_free(i);
4710 if (!istk)
4711 return NULL;
4712 if (istk->expansion && istk->expansion->finishes)
4713 break;
4718 * We must expand MMacro parameters and MMacro-local labels
4719 * _before_ we plunge into directive processing, to cope
4720 * with things like `%define something %1' such as STRUC
4721 * uses. Unless we're _defining_ a MMacro, in which case
4722 * those tokens should be left alone to go into the
4723 * definition; and unless we're in a non-emitting
4724 * condition, in which case we don't want to meddle with
4725 * anything.
4727 if (!defining && !(istk->conds && !emitting(istk->conds->state))
4728 && !(istk->mstk && !istk->mstk->in_progress)) {
4729 tline = expand_mmac_params(tline);
4733 * Check the line to see if it's a preprocessor directive.
4735 if (do_directive(tline) == DIRECTIVE_FOUND) {
4736 continue;
4737 } else if (defining) {
4739 * We're defining a multi-line macro. We emit nothing
4740 * at all, and just
4741 * shove the tokenized line on to the macro definition.
4743 Line *l = nasm_malloc(sizeof(Line));
4744 l->next = defining->expansion;
4745 l->first = tline;
4746 l->finishes = NULL;
4747 defining->expansion = l;
4748 continue;
4749 } else if (istk->conds && !emitting(istk->conds->state)) {
4751 * We're in a non-emitting branch of a condition block.
4752 * Emit nothing at all, not even a blank line: when we
4753 * emerge from the condition we'll give a line-number
4754 * directive so we keep our place correctly.
4756 free_tlist(tline);
4757 continue;
4758 } else if (istk->mstk && !istk->mstk->in_progress) {
4760 * We're in a %rep block which has been terminated, so
4761 * we're walking through to the %endrep without
4762 * emitting anything. Emit nothing at all, not even a
4763 * blank line: when we emerge from the %rep block we'll
4764 * give a line-number directive so we keep our place
4765 * correctly.
4767 free_tlist(tline);
4768 continue;
4769 } else {
4770 tline = expand_smacro(tline);
4771 if (!expand_mmacro(tline)) {
4773 * De-tokenize the line again, and emit it.
4775 line = detoken(tline, true);
4776 free_tlist(tline);
4777 break;
4778 } else {
4779 continue; /* expand_mmacro calls free_tlist */
4784 return line;
4787 static void pp_cleanup(int pass)
4789 if (defining) {
4790 if (defining->name) {
4791 error(ERR_NONFATAL,
4792 "end of file while still defining macro `%s'",
4793 defining->name);
4794 } else {
4795 error(ERR_NONFATAL, "end of file while still in %%rep");
4798 free_mmacro(defining);
4800 while (cstk)
4801 ctx_pop();
4802 free_macros();
4803 while (istk) {
4804 Include *i = istk;
4805 istk = istk->next;
4806 fclose(i->fp);
4807 nasm_free(i->fname);
4808 nasm_free(i);
4810 while (cstk)
4811 ctx_pop();
4812 nasm_free(src_set_fname(NULL));
4813 if (pass == 0) {
4814 IncPath *i;
4815 free_llist(predef);
4816 delete_Blocks();
4817 while ((i = ipath)) {
4818 ipath = i->next;
4819 if (i->path)
4820 nasm_free(i->path);
4821 nasm_free(i);
4826 void pp_include_path(char *path)
4828 IncPath *i;
4830 i = nasm_malloc(sizeof(IncPath));
4831 i->path = path ? nasm_strdup(path) : NULL;
4832 i->next = NULL;
4834 if (ipath) {
4835 IncPath *j = ipath;
4836 while (j->next)
4837 j = j->next;
4838 j->next = i;
4839 } else {
4840 ipath = i;
4844 void pp_pre_include(char *fname)
4846 Token *inc, *space, *name;
4847 Line *l;
4849 name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
4850 space = new_Token(name, TOK_WHITESPACE, NULL, 0);
4851 inc = new_Token(space, TOK_PREPROC_ID, "%include", 0);
4853 l = nasm_malloc(sizeof(Line));
4854 l->next = predef;
4855 l->first = inc;
4856 l->finishes = NULL;
4857 predef = l;
4860 void pp_pre_define(char *definition)
4862 Token *def, *space;
4863 Line *l;
4864 char *equals;
4866 equals = strchr(definition, '=');
4867 space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4868 def = new_Token(space, TOK_PREPROC_ID, "%define", 0);
4869 if (equals)
4870 *equals = ' ';
4871 space->next = tokenize(definition);
4872 if (equals)
4873 *equals = '=';
4875 l = nasm_malloc(sizeof(Line));
4876 l->next = predef;
4877 l->first = def;
4878 l->finishes = NULL;
4879 predef = l;
4882 void pp_pre_undefine(char *definition)
4884 Token *def, *space;
4885 Line *l;
4887 space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4888 def = new_Token(space, TOK_PREPROC_ID, "%undef", 0);
4889 space->next = tokenize(definition);
4891 l = nasm_malloc(sizeof(Line));
4892 l->next = predef;
4893 l->first = def;
4894 l->finishes = NULL;
4895 predef = l;
4899 * Added by Keith Kanios:
4901 * This function is used to assist with "runtime" preprocessor
4902 * directives. (e.g. pp_runtime("%define __BITS__ 64");)
4904 * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
4905 * PASS A VALID STRING TO THIS FUNCTION!!!!!
4908 void pp_runtime(char *definition)
4910 Token *def;
4912 def = tokenize(definition);
4913 if (do_directive(def) == NO_DIRECTIVE_FOUND)
4914 free_tlist(def);
4918 void pp_extra_stdmac(macros_t *macros)
4920 extrastdmac = macros;
4923 static void make_tok_num(Token * tok, int64_t val)
4925 char numbuf[20];
4926 snprintf(numbuf, sizeof(numbuf), "%"PRId64"", val);
4927 tok->text = nasm_strdup(numbuf);
4928 tok->type = TOK_NUMBER;
4931 Preproc nasmpp = {
4932 pp_reset,
4933 pp_getline,
4934 pp_cleanup