Avoid releasing intermediate files in the doc bundle
[nasm.git] / preproc.c
blob34d14f362fbad948d0177f2fbcbfe6b7092cbcdb
1 /* -*- mode: c; c-file-style: "bsd" -*- */
2 /* preproc.c macro preprocessor for the Netwide Assembler
4 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
5 * Julian Hall. All rights reserved. The software is
6 * redistributable under the licence given in the file "Licence"
7 * distributed in the NASM archive.
9 * initial version 18/iii/97 by Simon Tatham
12 /* Typical flow of text through preproc
14 * pp_getline gets tokenised lines, either
16 * from a macro expansion
18 * or
19 * {
20 * read_line gets raw text from stdmacpos, or predef, or current input file
21 * tokenise converts to tokens
22 * }
24 * expand_mmac_params is used to expand %1 etc., unless a macro is being
25 * defined or a false conditional is being processed
26 * (%0, %1, %+1, %-1, %%foo
28 * do_directive checks for directives
30 * expand_smacro is used to expand single line macros
32 * expand_mmacro is used to expand multi-line macros
34 * detoken is used to convert the line back to text
37 #include <stdio.h>
38 #include <stdarg.h>
39 #include <stdlib.h>
40 #include <stddef.h>
41 #include <string.h>
42 #include <ctype.h>
43 #include <limits.h>
45 #include "nasm.h"
46 #include "nasmlib.h"
48 typedef struct SMacro SMacro;
49 typedef struct MMacro MMacro;
50 typedef struct Context Context;
51 typedef struct Token Token;
52 typedef struct Blocks Blocks;
53 typedef struct Line Line;
54 typedef struct Include Include;
55 typedef struct Cond Cond;
56 typedef struct IncPath IncPath;
59 * Store the definition of a single-line macro.
61 struct SMacro
63 SMacro *next;
64 char *name;
65 int casesense;
66 int nparam;
67 int in_progress;
68 Token *expansion;
72 * Store the definition of a multi-line macro. This is also used to
73 * store the interiors of `%rep...%endrep' blocks, which are
74 * effectively self-re-invoking multi-line macros which simply
75 * don't have a name or bother to appear in the hash tables. %rep
76 * blocks are signified by having a NULL `name' field.
78 * In a MMacro describing a `%rep' block, the `in_progress' field
79 * isn't merely boolean, but gives the number of repeats left to
80 * run.
82 * The `next' field is used for storing MMacros in hash tables; the
83 * `next_active' field is for stacking them on istk entries.
85 * When a MMacro is being expanded, `params', `iline', `nparam',
86 * `paramlen', `rotate' and `unique' are local to the invocation.
88 struct MMacro
90 MMacro *next;
91 char *name;
92 int casesense;
93 int nparam_min, nparam_max;
94 int plus; /* is the last parameter greedy? */
95 int nolist; /* is this macro listing-inhibited? */
96 int in_progress;
97 Token *dlist; /* All defaults as one list */
98 Token **defaults; /* Parameter default pointers */
99 int ndefs; /* number of default parameters */
100 Line *expansion;
102 MMacro *next_active;
103 MMacro *rep_nest; /* used for nesting %rep */
104 Token **params; /* actual parameters */
105 Token *iline; /* invocation line */
106 int nparam, rotate, *paramlen;
107 unsigned long unique;
108 int lineno; /* Current line number on expansion */
112 * The context stack is composed of a linked list of these.
114 struct Context
116 Context *next;
117 SMacro *localmac;
118 char *name;
119 unsigned long number;
123 * This is the internal form which we break input lines up into.
124 * Typically stored in linked lists.
126 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
127 * necessarily used as-is, but is intended to denote the number of
128 * the substituted parameter. So in the definition
130 * %define a(x,y) ( (x) & ~(y) )
132 * the token representing `x' will have its type changed to
133 * TOK_SMAC_PARAM, but the one representing `y' will be
134 * TOK_SMAC_PARAM+1.
136 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
137 * which doesn't need quotes around it. Used in the pre-include
138 * mechanism as an alternative to trying to find a sensible type of
139 * quote to use on the filename we were passed.
141 struct Token
143 Token *next;
144 char *text;
145 SMacro *mac; /* associated macro for TOK_SMAC_END */
146 int type;
148 enum
150 TOK_WHITESPACE = 1, TOK_COMMENT, TOK_ID, TOK_PREPROC_ID, TOK_STRING,
151 TOK_NUMBER, TOK_SMAC_END, TOK_OTHER, TOK_SMAC_PARAM,
152 TOK_INTERNAL_STRING
156 * Multi-line macro definitions are stored as a linked list of
157 * these, which is essentially a container to allow several linked
158 * lists of Tokens.
160 * Note that in this module, linked lists are treated as stacks
161 * wherever possible. For this reason, Lines are _pushed_ on to the
162 * `expansion' field in MMacro structures, so that the linked list,
163 * if walked, would give the macro lines in reverse order; this
164 * means that we can walk the list when expanding a macro, and thus
165 * push the lines on to the `expansion' field in _istk_ in reverse
166 * order (so that when popped back off they are in the right
167 * order). It may seem cockeyed, and it relies on my design having
168 * an even number of steps in, but it works...
170 * Some of these structures, rather than being actual lines, are
171 * markers delimiting the end of the expansion of a given macro.
172 * This is for use in the cycle-tracking and %rep-handling code.
173 * Such structures have `finishes' non-NULL, and `first' NULL. All
174 * others have `finishes' NULL, but `first' may still be NULL if
175 * the line is blank.
177 struct Line
179 Line *next;
180 MMacro *finishes;
181 Token *first;
185 * To handle an arbitrary level of file inclusion, we maintain a
186 * stack (ie linked list) of these things.
188 struct Include
190 Include *next;
191 FILE *fp;
192 Cond *conds;
193 Line *expansion;
194 char *fname;
195 int lineno, lineinc;
196 MMacro *mstk; /* stack of active macros/reps */
200 * Include search path. This is simply a list of strings which get
201 * prepended, in turn, to the name of an include file, in an
202 * attempt to find the file if it's not in the current directory.
204 struct IncPath
206 IncPath *next;
207 char *path;
211 * Conditional assembly: we maintain a separate stack of these for
212 * each level of file inclusion. (The only reason we keep the
213 * stacks separate is to ensure that a stray `%endif' in a file
214 * included from within the true branch of a `%if' won't terminate
215 * it and cause confusion: instead, rightly, it'll cause an error.)
217 struct Cond
219 Cond *next;
220 int state;
222 enum
225 * These states are for use just after %if or %elif: IF_TRUE
226 * means the condition has evaluated to truth so we are
227 * currently emitting, whereas IF_FALSE means we are not
228 * currently emitting but will start doing so if a %else comes
229 * up. In these states, all directives are admissible: %elif,
230 * %else and %endif. (And of course %if.)
232 COND_IF_TRUE, COND_IF_FALSE,
234 * These states come up after a %else: ELSE_TRUE means we're
235 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
236 * any %elif or %else will cause an error.
238 COND_ELSE_TRUE, COND_ELSE_FALSE,
240 * This state means that we're not emitting now, and also that
241 * nothing until %endif will be emitted at all. It's for use in
242 * two circumstances: (i) when we've had our moment of emission
243 * and have now started seeing %elifs, and (ii) when the
244 * condition construct in question is contained within a
245 * non-emitting branch of a larger condition construct.
247 COND_NEVER
249 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
252 * Condition codes. Note that we use c_ prefix not C_ because C_ is
253 * used in nasm.h for the "real" condition codes. At _this_ level,
254 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
255 * ones, so we need a different enum...
257 static const char *conditions[] = {
258 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
259 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
260 "np", "ns", "nz", "o", "p", "pe", "po", "s", "z"
262 enum
264 c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE,
265 c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO,
266 c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_S, c_Z
268 static int inverse_ccs[] = {
269 c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE,
270 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,
271 c_Z, c_NO, c_NP, c_PO, c_PE, c_NS, c_NZ
275 * Directive names.
277 static const char *directives[] = {
278 "%arg",
279 "%assign", "%clear", "%define", "%elif", "%elifctx", "%elifdef",
280 "%elifid", "%elifidn", "%elifidni", "%elifmacro", "%elifnctx", "%elifndef",
281 "%elifnid", "%elifnidn", "%elifnidni", "%elifnmacro", "%elifnnum", "%elifnstr",
282 "%elifnum", "%elifstr", "%else", "%endif", "%endm", "%endmacro",
283 "%endrep", "%error", "%exitrep", "%iassign", "%idefine", "%if",
284 "%ifctx", "%ifdef", "%ifid", "%ifidn", "%ifidni", "%ifmacro", "%ifnctx",
285 "%ifndef", "%ifnid", "%ifnidn", "%ifnidni", "%ifnmacro", "%ifnnum",
286 "%ifnstr", "%ifnum", "%ifstr", "%imacro", "%include",
287 "%ixdefine", "%line",
288 "%local",
289 "%macro", "%pop", "%push", "%rep", "%repl", "%rotate",
290 "%stacksize",
291 "%strlen", "%substr", "%undef", "%xdefine"
293 enum
295 PP_ARG,
296 PP_ASSIGN, PP_CLEAR, PP_DEFINE, PP_ELIF, PP_ELIFCTX, PP_ELIFDEF,
297 PP_ELIFID, PP_ELIFIDN, PP_ELIFIDNI, PP_ELIFMACRO, PP_ELIFNCTX, PP_ELIFNDEF,
298 PP_ELIFNID, PP_ELIFNIDN, PP_ELIFNIDNI, PP_ELIFNMACRO, PP_ELIFNNUM, PP_ELIFNSTR,
299 PP_ELIFNUM, PP_ELIFSTR, PP_ELSE, PP_ENDIF, PP_ENDM, PP_ENDMACRO,
300 PP_ENDREP, PP_ERROR, PP_EXITREP, PP_IASSIGN, PP_IDEFINE, PP_IF,
301 PP_IFCTX, PP_IFDEF, PP_IFID, PP_IFIDN, PP_IFIDNI, PP_IFMACRO, PP_IFNCTX,
302 PP_IFNDEF, PP_IFNID, PP_IFNIDN, PP_IFNIDNI, PP_IFNMACRO, PP_IFNNUM,
303 PP_IFNSTR, PP_IFNUM, PP_IFSTR, PP_IMACRO, PP_INCLUDE,
304 PP_IXDEFINE, PP_LINE,
305 PP_LOCAL,
306 PP_MACRO, PP_POP, PP_PUSH, PP_REP, PP_REPL, PP_ROTATE,
307 PP_STACKSIZE,
308 PP_STRLEN, PP_SUBSTR, PP_UNDEF, PP_XDEFINE
311 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
312 static int is_condition(int arg)
314 return ((arg >= PP_ELIF) && (arg <= PP_ENDIF)) ||
315 ((arg >= PP_IF) && (arg <= PP_IFSTR));
318 /* For TASM compatibility we need to be able to recognise TASM compatible
319 * conditional compilation directives. Using the NASM pre-processor does
320 * not work, so we look for them specifically from the following list and
321 * then jam in the equivalent NASM directive into the input stream.
324 #ifndef MAX
325 # define MAX(a,b) ( ((a) > (b)) ? (a) : (b))
326 #endif
328 enum
330 TM_ARG, TM_ELIF, TM_ELSE, TM_ENDIF, TM_IF, TM_IFDEF, TM_IFDIFI,
331 TM_IFNDEF, TM_INCLUDE, TM_LOCAL
334 static const char *tasm_directives[] = {
335 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
336 "ifndef", "include", "local"
339 static int StackSize = 4;
340 static char *StackPointer = "ebp";
341 static int ArgOffset = 8;
342 static int LocalOffset = 4;
345 static Context *cstk;
346 static Include *istk;
347 static IncPath *ipath = NULL;
349 static efunc _error; /* Pointer to client-provided error reporting function */
350 static evalfunc evaluate;
352 static int pass; /* HACK: pass 0 = generate dependencies only */
354 static unsigned long unique; /* unique identifier numbers */
356 static Line *predef = NULL;
358 static ListGen *list;
361 * The number of hash values we use for the macro lookup tables.
362 * FIXME: We should *really* be able to configure this at run time,
363 * or even have the hash table automatically expanding when necessary.
365 #define NHASH 31
368 * The current set of multi-line macros we have defined.
370 static MMacro *mmacros[NHASH];
373 * The current set of single-line macros we have defined.
375 static SMacro *smacros[NHASH];
378 * The multi-line macro we are currently defining, or the %rep
379 * block we are currently reading, if any.
381 static MMacro *defining;
384 * The number of macro parameters to allocate space for at a time.
386 #define PARAM_DELTA 16
389 * The standard macro set: defined as `static char *stdmac[]'. Also
390 * gives our position in the macro set, when we're processing it.
392 #include "macros.c"
393 static const char **stdmacpos;
396 * The extra standard macros that come from the object format, if
397 * any.
399 static char **extrastdmac = NULL;
400 int any_extrastdmac;
403 * Tokens are allocated in blocks to improve speed
405 #define TOKEN_BLOCKSIZE 4096
406 static Token *freeTokens = NULL;
407 struct Blocks {
408 Blocks *next;
409 void *chunk;
412 static Blocks blocks = { NULL, NULL };
415 * Forward declarations.
417 static Token *expand_mmac_params(Token * tline);
418 static Token *expand_smacro(Token * tline);
419 static Token *expand_id(Token * tline);
420 static Context *get_ctx(char *name, int all_contexts);
421 static void make_tok_num(Token * tok, long val);
422 static void error(int severity, const char *fmt, ...);
423 static void *new_Block(size_t size);
424 static void delete_Blocks(void);
425 static Token *new_Token(Token * next, int type, char *text, int txtlen);
426 static Token *delete_Token(Token * t);
429 * Macros for safe checking of token pointers, avoid *(NULL)
431 #define tok_type_(x,t) ((x) && (x)->type == (t))
432 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
433 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
434 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
436 /* Handle TASM specific directives, which do not contain a % in
437 * front of them. We do it here because I could not find any other
438 * place to do it for the moment, and it is a hack (ideally it would
439 * be nice to be able to use the NASM pre-processor to do it).
441 static char *
442 check_tasm_directive(char *line)
444 int i, j, k, m, len;
445 char *p = line, *oldline, oldchar;
447 /* Skip whitespace */
448 while (isspace(*p) && *p != 0)
449 p++;
451 /* Binary search for the directive name */
452 i = -1;
453 j = sizeof(tasm_directives) / sizeof(*tasm_directives);
454 len = 0;
455 while (!isspace(p[len]) && p[len] != 0)
456 len++;
457 if (len)
459 oldchar = p[len];
460 p[len] = 0;
461 while (j - i > 1)
463 k = (j + i) / 2;
464 m = nasm_stricmp(p, tasm_directives[k]);
465 if (m == 0)
467 /* We have found a directive, so jam a % in front of it
468 * so that NASM will then recognise it as one if it's own.
470 p[len] = oldchar;
471 len = strlen(p);
472 oldline = line;
473 line = nasm_malloc(len + 2);
474 line[0] = '%';
475 if (k == TM_IFDIFI)
477 /* NASM does not recognise IFDIFI, so we convert it to
478 * %ifdef BOGUS. This is not used in NASM comaptible
479 * code, but does need to parse for the TASM macro
480 * package.
482 strcpy(line + 1, "ifdef BOGUS");
484 else
486 memcpy(line + 1, p, len + 1);
488 nasm_free(oldline);
489 return line;
491 else if (m < 0)
493 j = k;
495 else
496 i = k;
498 p[len] = oldchar;
500 return line;
504 * The pre-preprocessing stage... This function translates line
505 * number indications as they emerge from GNU cpp (`# lineno "file"
506 * flags') into NASM preprocessor line number indications (`%line
507 * lineno file').
509 static char *
510 prepreproc(char *line)
512 int lineno, fnlen;
513 char *fname, *oldline;
515 if (line[0] == '#' && line[1] == ' ')
517 oldline = line;
518 fname = oldline + 2;
519 lineno = atoi(fname);
520 fname += strspn(fname, "0123456789 ");
521 if (*fname == '"')
522 fname++;
523 fnlen = strcspn(fname, "\"");
524 line = nasm_malloc(20 + fnlen);
525 sprintf(line, "%%line %d %.*s", lineno, fnlen, fname);
526 nasm_free(oldline);
528 if (tasm_compatible_mode)
529 return check_tasm_directive(line);
530 return line;
534 * The hash function for macro lookups. Note that due to some
535 * macros having case-insensitive names, the hash function must be
536 * invariant under case changes. We implement this by applying a
537 * perfectly normal hash function to the uppercase of the string.
539 static int
540 hash(char *s)
542 unsigned int h = 0;
543 int i = 0;
545 * Powers of three, mod 31.
547 static const int multipliers[] = {
548 1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10,
549 30, 28, 22, 4, 12, 5, 15, 14, 11, 2, 6, 18, 23, 7, 21
553 while (*s)
555 h += multipliers[i] * (unsigned char) (toupper(*s));
556 s++;
557 if (++i >= sizeof(multipliers) / sizeof(*multipliers))
558 i = 0;
560 h %= NHASH;
561 return h;
565 * Free a linked list of tokens.
567 static void
568 free_tlist(Token * list)
570 while (list)
572 list = delete_Token(list);
577 * Free a linked list of lines.
579 static void
580 free_llist(Line * list)
582 Line *l;
583 while (list)
585 l = list;
586 list = list->next;
587 free_tlist(l->first);
588 nasm_free(l);
593 * Free an MMacro
595 static void
596 free_mmacro(MMacro * m)
598 nasm_free(m->name);
599 free_tlist(m->dlist);
600 nasm_free(m->defaults);
601 free_llist(m->expansion);
602 nasm_free(m);
606 * Pop the context stack.
608 static void
609 ctx_pop(void)
611 Context *c = cstk;
612 SMacro *smac, *s;
614 cstk = cstk->next;
615 smac = c->localmac;
616 while (smac)
618 s = smac;
619 smac = smac->next;
620 nasm_free(s->name);
621 free_tlist(s->expansion);
622 nasm_free(s);
624 nasm_free(c->name);
625 nasm_free(c);
628 #define BUF_DELTA 512
630 * Read a line from the top file in istk, handling multiple CR/LFs
631 * at the end of the line read, and handling spurious ^Zs. Will
632 * return lines from the standard macro set if this has not already
633 * been done.
635 static char *
636 read_line(void)
638 char *buffer, *p, *q;
639 int bufsize, continued_count;
641 if (stdmacpos)
643 if (*stdmacpos)
645 char *ret = nasm_strdup(*stdmacpos++);
646 if (!*stdmacpos && any_extrastdmac)
648 stdmacpos = extrastdmac;
649 any_extrastdmac = FALSE;
650 return ret;
653 * Nasty hack: here we push the contents of `predef' on
654 * to the top-level expansion stack, since this is the
655 * most convenient way to implement the pre-include and
656 * pre-define features.
658 if (!*stdmacpos)
660 Line *pd, *l;
661 Token *head, **tail, *t;
663 for (pd = predef; pd; pd = pd->next)
665 head = NULL;
666 tail = &head;
667 for (t = pd->first; t; t = t->next)
669 *tail = new_Token(NULL, t->type, t->text, 0);
670 tail = &(*tail)->next;
672 l = nasm_malloc(sizeof(Line));
673 l->next = istk->expansion;
674 l->first = head;
675 l->finishes = FALSE;
676 istk->expansion = l;
679 return ret;
681 else
683 stdmacpos = NULL;
687 bufsize = BUF_DELTA;
688 buffer = nasm_malloc(BUF_DELTA);
689 p = buffer;
690 continued_count = 0;
691 while (1)
693 q = fgets(p, bufsize - (p - buffer), istk->fp);
694 if (!q)
695 break;
696 p += strlen(p);
697 if (p > buffer && p[-1] == '\n')
699 /* Convert backslash-CRLF line continuation sequences into
700 nothing at all (for DOS and Windows) */
701 if (((p - 2) > buffer) && (p[-3] == '\\') && (p[-2] == '\r')) {
702 p -= 3;
703 *p = 0;
704 continued_count++;
706 /* Also convert backslash-LF line continuation sequences into
707 nothing at all (for Unix) */
708 else if (((p - 1) > buffer) && (p[-2] == '\\')) {
709 p -= 2;
710 *p = 0;
711 continued_count++;
713 else {
714 break;
717 if (p - buffer > bufsize - 10)
719 long offset = p - buffer;
720 bufsize += BUF_DELTA;
721 buffer = nasm_realloc(buffer, bufsize);
722 p = buffer + offset; /* prevent stale-pointer problems */
726 if (!q && p == buffer)
728 nasm_free(buffer);
729 return NULL;
732 src_set_linnum(src_get_linnum() + istk->lineinc + (continued_count * istk->lineinc));
735 * Play safe: remove CRs as well as LFs, if any of either are
736 * present at the end of the line.
738 while (--p >= buffer && (*p == '\n' || *p == '\r'))
739 *p = '\0';
742 * Handle spurious ^Z, which may be inserted into source files
743 * by some file transfer utilities.
745 buffer[strcspn(buffer, "\032")] = '\0';
747 list->line(LIST_READ, buffer);
749 return buffer;
753 * Tokenise a line of text. This is a very simple process since we
754 * don't need to parse the value out of e.g. numeric tokens: we
755 * simply split one string into many.
757 static Token *
758 tokenise(char *line)
760 char *p = line;
761 int type;
762 Token *list = NULL;
763 Token *t, **tail = &list;
765 while (*line)
767 p = line;
768 if (*p == '%')
770 p++;
771 if ( isdigit(*p) ||
772 ((*p == '-' || *p == '+') && isdigit(p[1])) ||
773 ((*p == '+') && (isspace(p[1]) || !p[1])))
777 p++;
779 while (isdigit(*p));
780 type = TOK_PREPROC_ID;
782 else if (*p == '{')
784 p++;
785 while (*p && *p != '}')
787 p[-1] = *p;
788 p++;
790 p[-1] = '\0';
791 if (*p)
792 p++;
793 type = TOK_PREPROC_ID;
795 else if (isidchar(*p) ||
796 ((*p == '!' || *p == '%' || *p == '$') &&
797 isidchar(p[1])))
801 p++;
803 while (isidchar(*p));
804 type = TOK_PREPROC_ID;
806 else
808 type = TOK_OTHER;
809 if (*p == '%')
810 p++;
813 else if (isidstart(*p) || (*p == '$' && isidstart(p[1])))
815 type = TOK_ID;
816 p++;
817 while (*p && isidchar(*p))
818 p++;
820 else if (*p == '\'' || *p == '"')
823 * A string token.
825 char c = *p;
826 p++;
827 type = TOK_STRING;
828 while (*p && *p != c)
829 p++;
830 if (*p)
832 p++;
834 else
836 error(ERR_WARNING, "unterminated string");
839 else if (isnumstart(*p))
842 * A number token.
844 type = TOK_NUMBER;
845 p++;
846 while (*p && isnumchar(*p))
847 p++;
849 else if (isspace(*p))
851 type = TOK_WHITESPACE;
852 p++;
853 while (*p && isspace(*p))
854 p++;
856 * Whitespace just before end-of-line is discarded by
857 * pretending it's a comment; whitespace just before a
858 * comment gets lumped into the comment.
860 if (!*p || *p == ';')
862 type = TOK_COMMENT;
863 while (*p)
864 p++;
867 else if (*p == ';')
869 type = TOK_COMMENT;
870 while (*p)
871 p++;
873 else
876 * Anything else is an operator of some kind. We check
877 * for all the double-character operators (>>, <<, //,
878 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
879 * else is a single-character operator.
881 type = TOK_OTHER;
882 if ((p[0] == '>' && p[1] == '>') ||
883 (p[0] == '<' && p[1] == '<') ||
884 (p[0] == '/' && p[1] == '/') ||
885 (p[0] == '<' && p[1] == '=') ||
886 (p[0] == '>' && p[1] == '=') ||
887 (p[0] == '=' && p[1] == '=') ||
888 (p[0] == '!' && p[1] == '=') ||
889 (p[0] == '<' && p[1] == '>') ||
890 (p[0] == '&' && p[1] == '&') ||
891 (p[0] == '|' && p[1] == '|') ||
892 (p[0] == '^' && p[1] == '^'))
894 p++;
896 p++;
898 if (type != TOK_COMMENT)
900 *tail = t = new_Token(NULL, type, line, p - line);
901 tail = &t->next;
903 line = p;
905 return list;
909 * this function allocates a new managed block of memory and
910 * returns a pointer to the block. The managed blocks are
911 * deleted only all at once by the delete_Blocks function.
913 static void *
914 new_Block(size_t size)
916 Blocks *b = &blocks;
918 /* first, get to the end of the linked list */
919 while (b->next)
920 b = b->next;
921 /* now allocate the requested chunk */
922 b->chunk = nasm_malloc(size);
924 /* now allocate a new block for the next request */
925 b->next = nasm_malloc(sizeof(Blocks));
926 /* and initialize the contents of the new block */
927 b->next->next = NULL;
928 b->next->chunk = NULL;
929 return b->chunk;
933 * this function deletes all managed blocks of memory
935 static void
936 delete_Blocks(void)
938 Blocks *a,*b = &blocks;
941 * keep in mind that the first block, pointed to by blocks
942 * is a static and not dynamically allocated, so we don't
943 * free it.
945 while (b)
947 if (b->chunk)
948 nasm_free(b->chunk);
949 a = b;
950 b = b->next;
951 if (a != &blocks)
952 nasm_free(a);
957 * this function creates a new Token and passes a pointer to it
958 * back to the caller. It sets the type and text elements, and
959 * also the mac and next elements to NULL.
961 static Token *
962 new_Token(Token * next, int type, char *text, int txtlen)
964 Token *t;
965 int i;
967 if (freeTokens == NULL)
969 freeTokens = (Token *)new_Block(TOKEN_BLOCKSIZE * sizeof(Token));
970 for (i = 0; i < TOKEN_BLOCKSIZE - 1; i++)
971 freeTokens[i].next = &freeTokens[i + 1];
972 freeTokens[i].next = NULL;
974 t = freeTokens;
975 freeTokens = t->next;
976 t->next = next;
977 t->mac = NULL;
978 t->type = type;
979 if (type == TOK_WHITESPACE || text == NULL)
981 t->text = NULL;
983 else
985 if (txtlen == 0)
986 txtlen = strlen(text);
987 t->text = nasm_malloc(1 + txtlen);
988 strncpy(t->text, text, txtlen);
989 t->text[txtlen] = '\0';
991 return t;
994 static Token *
995 delete_Token(Token * t)
997 Token *next = t->next;
998 nasm_free(t->text);
999 t->next = freeTokens;
1000 freeTokens = t;
1001 return next;
1005 * Convert a line of tokens back into text.
1006 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1007 * will be transformed into ..@ctxnum.xxx
1009 static char *
1010 detoken(Token * tlist, int expand_locals)
1012 Token *t;
1013 int len;
1014 char *line, *p;
1016 len = 0;
1017 for (t = tlist; t; t = t->next)
1019 if (t->type == TOK_PREPROC_ID && t->text[1] == '!')
1021 char *p = getenv(t->text + 2);
1022 nasm_free(t->text);
1023 if (p)
1024 t->text = nasm_strdup(p);
1025 else
1026 t->text = NULL;
1028 /* Expand local macros here and not during preprocessing */
1029 if (expand_locals &&
1030 t->type == TOK_PREPROC_ID && t->text &&
1031 t->text[0] == '%' && t->text[1] == '$')
1033 Context *ctx = get_ctx(t->text, FALSE);
1034 if (ctx)
1036 char buffer[40];
1037 char *p, *q = t->text + 2;
1039 q += strspn(q, "$");
1040 sprintf(buffer, "..@%lu.", ctx->number);
1041 p = nasm_strcat(buffer, q);
1042 nasm_free(t->text);
1043 t->text = p;
1046 if (t->type == TOK_WHITESPACE)
1048 len++;
1050 else if (t->text)
1052 len += strlen(t->text);
1055 p = line = nasm_malloc(len + 1);
1056 for (t = tlist; t; t = t->next)
1058 if (t->type == TOK_WHITESPACE)
1060 *p = ' ';
1061 p++;
1062 *p = '\0';
1064 else if (t->text)
1066 strcpy(p, t->text);
1067 p += strlen(p);
1070 *p = '\0';
1071 return line;
1075 * A scanner, suitable for use by the expression evaluator, which
1076 * operates on a line of Tokens. Expects a pointer to a pointer to
1077 * the first token in the line to be passed in as its private_data
1078 * field.
1080 static int
1081 ppscan(void *private_data, struct tokenval *tokval)
1083 Token **tlineptr = private_data;
1084 Token *tline;
1088 tline = *tlineptr;
1089 *tlineptr = tline ? tline->next : NULL;
1091 while (tline && (tline->type == TOK_WHITESPACE ||
1092 tline->type == TOK_COMMENT));
1094 if (!tline)
1095 return tokval->t_type = TOKEN_EOS;
1097 if (tline->text[0] == '$' && !tline->text[1])
1098 return tokval->t_type = TOKEN_HERE;
1099 if (tline->text[0] == '$' && tline->text[1] == '$' && !tline->text[1])
1100 return tokval->t_type = TOKEN_BASE;
1102 if (tline->type == TOK_ID)
1104 tokval->t_charptr = tline->text;
1105 if (tline->text[0] == '$')
1107 tokval->t_charptr++;
1108 return tokval->t_type = TOKEN_ID;
1112 * This is the only special case we actually need to worry
1113 * about in this restricted context.
1115 if (!nasm_stricmp(tline->text, "seg"))
1116 return tokval->t_type = TOKEN_SEG;
1118 return tokval->t_type = TOKEN_ID;
1121 if (tline->type == TOK_NUMBER)
1123 int rn_error;
1125 tokval->t_integer = readnum(tline->text, &rn_error);
1126 if (rn_error)
1127 return tokval->t_type = TOKEN_ERRNUM;
1128 tokval->t_charptr = NULL;
1129 return tokval->t_type = TOKEN_NUM;
1132 if (tline->type == TOK_STRING)
1134 int rn_warn;
1135 char q, *r;
1136 int l;
1138 r = tline->text;
1139 q = *r++;
1140 l = strlen(r);
1142 if (l == 0 || r[l - 1] != q)
1143 return tokval->t_type = TOKEN_ERRNUM;
1144 tokval->t_integer = readstrnum(r, l - 1, &rn_warn);
1145 if (rn_warn)
1146 error(ERR_WARNING | ERR_PASS1, "character constant too long");
1147 tokval->t_charptr = NULL;
1148 return tokval->t_type = TOKEN_NUM;
1151 if (tline->type == TOK_OTHER)
1153 if (!strcmp(tline->text, "<<"))
1154 return tokval->t_type = TOKEN_SHL;
1155 if (!strcmp(tline->text, ">>"))
1156 return tokval->t_type = TOKEN_SHR;
1157 if (!strcmp(tline->text, "//"))
1158 return tokval->t_type = TOKEN_SDIV;
1159 if (!strcmp(tline->text, "%%"))
1160 return tokval->t_type = TOKEN_SMOD;
1161 if (!strcmp(tline->text, "=="))
1162 return tokval->t_type = TOKEN_EQ;
1163 if (!strcmp(tline->text, "<>"))
1164 return tokval->t_type = TOKEN_NE;
1165 if (!strcmp(tline->text, "!="))
1166 return tokval->t_type = TOKEN_NE;
1167 if (!strcmp(tline->text, "<="))
1168 return tokval->t_type = TOKEN_LE;
1169 if (!strcmp(tline->text, ">="))
1170 return tokval->t_type = TOKEN_GE;
1171 if (!strcmp(tline->text, "&&"))
1172 return tokval->t_type = TOKEN_DBL_AND;
1173 if (!strcmp(tline->text, "^^"))
1174 return tokval->t_type = TOKEN_DBL_XOR;
1175 if (!strcmp(tline->text, "||"))
1176 return tokval->t_type = TOKEN_DBL_OR;
1180 * We have no other options: just return the first character of
1181 * the token text.
1183 return tokval->t_type = tline->text[0];
1187 * Compare a string to the name of an existing macro; this is a
1188 * simple wrapper which calls either strcmp or nasm_stricmp
1189 * depending on the value of the `casesense' parameter.
1191 static int
1192 mstrcmp(char *p, char *q, int casesense)
1194 return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
1198 * Return the Context structure associated with a %$ token. Return
1199 * NULL, having _already_ reported an error condition, if the
1200 * context stack isn't deep enough for the supplied number of $
1201 * signs.
1202 * If all_contexts == TRUE, contexts that enclose current are
1203 * also scanned for such smacro, until it is found; if not -
1204 * only the context that directly results from the number of $'s
1205 * in variable's name.
1207 static Context *
1208 get_ctx(char *name, int all_contexts)
1210 Context *ctx;
1211 SMacro *m;
1212 int i;
1214 if (!name || name[0] != '%' || name[1] != '$')
1215 return NULL;
1217 if (!cstk)
1219 error(ERR_NONFATAL, "`%s': context stack is empty", name);
1220 return NULL;
1223 for (i = strspn(name + 2, "$"), ctx = cstk; (i > 0) && ctx; i--)
1225 ctx = ctx->next;
1226 /* i--; Lino - 02/25/02 */
1228 if (!ctx)
1230 error(ERR_NONFATAL, "`%s': context stack is only"
1231 " %d level%s deep", name, i - 1, (i == 2 ? "" : "s"));
1232 return NULL;
1234 if (!all_contexts)
1235 return ctx;
1239 /* Search for this smacro in found context */
1240 m = ctx->localmac;
1241 while (m)
1243 if (!mstrcmp(m->name, name, m->casesense))
1244 return ctx;
1245 m = m->next;
1247 ctx = ctx->next;
1249 while (ctx);
1250 return NULL;
1253 /* Add a slash to the end of a path if it is missing. We use the
1254 * forward slash to make it compatible with Unix systems.
1256 static void
1257 backslash(char *s)
1259 int pos = strlen(s);
1260 if (s[pos - 1] != '\\' && s[pos - 1] != '/')
1262 s[pos] = '/';
1263 s[pos + 1] = '\0';
1268 * Open an include file. This routine must always return a valid
1269 * file pointer if it returns - it's responsible for throwing an
1270 * ERR_FATAL and bombing out completely if not. It should also try
1271 * the include path one by one until it finds the file or reaches
1272 * the end of the path.
1274 static FILE *
1275 inc_fopen(char *file)
1277 FILE *fp;
1278 char *prefix = "", *combine;
1279 IncPath *ip = ipath;
1280 static int namelen = 0;
1281 int len = strlen(file);
1283 while (1)
1285 combine = nasm_malloc(strlen(prefix) + 1 + len + 1);
1286 strcpy(combine, prefix);
1287 if (prefix[0] != 0)
1288 backslash(combine);
1289 strcat(combine, file);
1290 fp = fopen(combine, "r");
1291 if (pass == 0 && fp)
1293 namelen += strlen(combine) + 1;
1294 if (namelen > 62)
1296 printf(" \\\n ");
1297 namelen = 2;
1299 printf(" %s", combine);
1301 nasm_free(combine);
1302 if (fp)
1303 return fp;
1304 if (!ip)
1305 break;
1306 prefix = ip->path;
1307 ip = ip->next;
1310 error(ERR_FATAL, "unable to open include file `%s'", file);
1311 return NULL; /* never reached - placate compilers */
1315 * Determine if we should warn on defining a single-line macro of
1316 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1317 * return TRUE if _any_ single-line macro of that name is defined.
1318 * Otherwise, will return TRUE if a single-line macro with either
1319 * `nparam' or no parameters is defined.
1321 * If a macro with precisely the right number of parameters is
1322 * defined, or nparam is -1, the address of the definition structure
1323 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1324 * is NULL, no action will be taken regarding its contents, and no
1325 * error will occur.
1327 * Note that this is also called with nparam zero to resolve
1328 * `ifdef'.
1330 * If you already know which context macro belongs to, you can pass
1331 * the context pointer as first parameter; if you won't but name begins
1332 * with %$ the context will be automatically computed. If all_contexts
1333 * is true, macro will be searched in outer contexts as well.
1335 static int
1336 smacro_defined(Context * ctx, char *name, int nparam, SMacro ** defn,
1337 int nocase)
1339 SMacro *m;
1341 if (ctx)
1342 m = ctx->localmac;
1343 else if (name[0] == '%' && name[1] == '$')
1345 if (cstk)
1346 ctx = get_ctx(name, FALSE);
1347 if (!ctx)
1348 return FALSE; /* got to return _something_ */
1349 m = ctx->localmac;
1351 else
1352 m = smacros[hash(name)];
1354 while (m)
1356 if (!mstrcmp(m->name, name, m->casesense && nocase) &&
1357 (nparam <= 0 || m->nparam == 0 || nparam == m->nparam))
1359 if (defn)
1361 if (nparam == m->nparam || nparam == -1)
1362 *defn = m;
1363 else
1364 *defn = NULL;
1366 return TRUE;
1368 m = m->next;
1371 return FALSE;
1375 * Count and mark off the parameters in a multi-line macro call.
1376 * This is called both from within the multi-line macro expansion
1377 * code, and also to mark off the default parameters when provided
1378 * in a %macro definition line.
1380 static void
1381 count_mmac_params(Token * t, int *nparam, Token *** params)
1383 int paramsize, brace;
1385 *nparam = paramsize = 0;
1386 *params = NULL;
1387 while (t)
1389 if (*nparam >= paramsize)
1391 paramsize += PARAM_DELTA;
1392 *params = nasm_realloc(*params, sizeof(**params) * paramsize);
1394 skip_white_(t);
1395 brace = FALSE;
1396 if (tok_is_(t, "{"))
1397 brace = TRUE;
1398 (*params)[(*nparam)++] = t;
1399 while (tok_isnt_(t, brace ? "}" : ","))
1400 t = t->next;
1401 if (t)
1402 { /* got a comma/brace */
1403 t = t->next;
1404 if (brace)
1407 * Now we've found the closing brace, look further
1408 * for the comma.
1410 skip_white_(t);
1411 if (tok_isnt_(t, ","))
1413 error(ERR_NONFATAL,
1414 "braces do not enclose all of macro parameter");
1415 while (tok_isnt_(t, ","))
1416 t = t->next;
1418 if (t)
1419 t = t->next; /* eat the comma */
1426 * Determine whether one of the various `if' conditions is true or
1427 * not.
1429 * We must free the tline we get passed.
1431 static int
1432 if_condition(Token * tline, int i)
1434 int j, casesense;
1435 Token *t, *tt, **tptr, *origline;
1436 struct tokenval tokval;
1437 expr *evalresult;
1439 origline = tline;
1441 switch (i)
1443 case PP_IFCTX:
1444 case PP_ELIFCTX:
1445 case PP_IFNCTX:
1446 case PP_ELIFNCTX:
1447 j = FALSE; /* have we matched yet? */
1448 while (cstk && tline)
1450 skip_white_(tline);
1451 if (!tline || tline->type != TOK_ID)
1453 error(ERR_NONFATAL,
1454 "`%s' expects context identifiers",
1455 directives[i]);
1456 free_tlist(origline);
1457 return -1;
1459 if (!nasm_stricmp(tline->text, cstk->name))
1460 j = TRUE;
1461 tline = tline->next;
1463 if (i == PP_IFNCTX || i == PP_ELIFNCTX)
1464 j = !j;
1465 free_tlist(origline);
1466 return j;
1468 case PP_IFDEF:
1469 case PP_ELIFDEF:
1470 case PP_IFNDEF:
1471 case PP_ELIFNDEF:
1472 j = FALSE; /* have we matched yet? */
1473 while (tline)
1475 skip_white_(tline);
1476 if (!tline || (tline->type != TOK_ID &&
1477 (tline->type != TOK_PREPROC_ID ||
1478 tline->text[1] != '$')))
1480 error(ERR_NONFATAL,
1481 "`%s' expects macro identifiers",
1482 directives[i]);
1483 free_tlist(origline);
1484 return -1;
1486 if (smacro_defined(NULL, tline->text, 0, NULL, 1))
1487 j = TRUE;
1488 tline = tline->next;
1490 if (i == PP_IFNDEF || i == PP_ELIFNDEF)
1491 j = !j;
1492 free_tlist(origline);
1493 return j;
1495 case PP_IFIDN:
1496 case PP_ELIFIDN:
1497 case PP_IFNIDN:
1498 case PP_ELIFNIDN:
1499 case PP_IFIDNI:
1500 case PP_ELIFIDNI:
1501 case PP_IFNIDNI:
1502 case PP_ELIFNIDNI:
1503 tline = expand_smacro(tline);
1504 t = tt = tline;
1505 while (tok_isnt_(tt, ","))
1506 tt = tt->next;
1507 if (!tt)
1509 error(ERR_NONFATAL,
1510 "`%s' expects two comma-separated arguments",
1511 directives[i]);
1512 free_tlist(tline);
1513 return -1;
1515 tt = tt->next;
1516 casesense = (i == PP_IFIDN || i == PP_ELIFIDN ||
1517 i == PP_IFNIDN || i == PP_ELIFNIDN);
1518 j = TRUE; /* assume equality unless proved not */
1519 while ((t->type != TOK_OTHER || strcmp(t->text, ",")) && tt)
1521 if (tt->type == TOK_OTHER && !strcmp(tt->text, ","))
1523 error(ERR_NONFATAL, "`%s': more than one comma on line",
1524 directives[i]);
1525 free_tlist(tline);
1526 return -1;
1528 if (t->type == TOK_WHITESPACE)
1530 t = t->next;
1531 continue;
1533 else if (tt->type == TOK_WHITESPACE)
1535 tt = tt->next;
1536 continue;
1538 else if (tt->type != t->type ||
1539 mstrcmp(tt->text, t->text, casesense))
1541 j = FALSE; /* found mismatching tokens */
1542 break;
1544 else
1546 t = t->next;
1547 tt = tt->next;
1548 continue;
1551 if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
1552 j = FALSE; /* trailing gunk on one end or other */
1553 if (i == PP_IFNIDN || i == PP_ELIFNIDN ||
1554 i == PP_IFNIDNI || i == PP_ELIFNIDNI)
1555 j = !j;
1556 free_tlist(tline);
1557 return j;
1559 case PP_IFMACRO:
1560 case PP_ELIFMACRO:
1561 case PP_IFNMACRO:
1562 case PP_ELIFNMACRO:
1564 int found = 0;
1565 MMacro searching, *mmac;
1567 tline = tline->next;
1568 skip_white_(tline);
1569 tline = expand_id(tline);
1570 if (!tok_type_(tline, TOK_ID))
1572 error(ERR_NONFATAL,
1573 "`%s' expects a macro name",
1574 directives[i]);
1575 return -1;
1577 searching.name = nasm_strdup(tline->text);
1578 searching.casesense = (i == PP_MACRO);
1579 searching.plus = FALSE;
1580 searching.nolist = FALSE;
1581 searching.in_progress = FALSE;
1582 searching.rep_nest = NULL;
1583 searching.nparam_min = 0;
1584 searching.nparam_max = INT_MAX;
1585 tline = expand_smacro(tline->next);
1586 skip_white_(tline);
1587 if (!tline)
1589 } else if (!tok_type_(tline, TOK_NUMBER))
1591 error(ERR_NONFATAL,
1592 "`%s' expects a parameter count or nothing",
1593 directives[i]);
1595 else
1597 searching.nparam_min = searching.nparam_max =
1598 readnum(tline->text, &j);
1599 if (j)
1600 error(ERR_NONFATAL,
1601 "unable to parse parameter count `%s'",
1602 tline->text);
1604 if (tline && tok_is_(tline->next, "-"))
1606 tline = tline->next->next;
1607 if (tok_is_(tline, "*"))
1608 searching.nparam_max = INT_MAX;
1609 else if (!tok_type_(tline, TOK_NUMBER))
1610 error(ERR_NONFATAL,
1611 "`%s' expects a parameter count after `-'",
1612 directives[i]);
1613 else
1615 searching.nparam_max = readnum(tline->text, &j);
1616 if (j)
1617 error(ERR_NONFATAL,
1618 "unable to parse parameter count `%s'",
1619 tline->text);
1620 if (searching.nparam_min > searching.nparam_max)
1621 error(ERR_NONFATAL,
1622 "minimum parameter count exceeds maximum");
1625 if (tline && tok_is_(tline->next, "+"))
1627 tline = tline->next;
1628 searching.plus = TRUE;
1630 mmac = mmacros[hash(searching.name)];
1631 while (mmac)
1633 if (!strcmp(mmac->name, searching.name) &&
1634 (mmac->nparam_min <= searching.nparam_max
1635 || searching.plus)
1636 && (searching.nparam_min <= mmac->nparam_max
1637 || mmac->plus))
1639 found = TRUE;
1640 break;
1642 mmac = mmac->next;
1644 nasm_free(searching.name);
1645 free_tlist(origline);
1646 if (i == PP_IFNMACRO || i == PP_ELIFNMACRO)
1647 found = !found;
1648 return found;
1651 case PP_IFID:
1652 case PP_ELIFID:
1653 case PP_IFNID:
1654 case PP_ELIFNID:
1655 case PP_IFNUM:
1656 case PP_ELIFNUM:
1657 case PP_IFNNUM:
1658 case PP_ELIFNNUM:
1659 case PP_IFSTR:
1660 case PP_ELIFSTR:
1661 case PP_IFNSTR:
1662 case PP_ELIFNSTR:
1663 tline = expand_smacro(tline);
1664 t = tline;
1665 while (tok_type_(t, TOK_WHITESPACE))
1666 t = t->next;
1667 j = FALSE; /* placate optimiser */
1668 if (t)
1669 switch (i)
1671 case PP_IFID:
1672 case PP_ELIFID:
1673 case PP_IFNID:
1674 case PP_ELIFNID:
1675 j = (t->type == TOK_ID);
1676 break;
1677 case PP_IFNUM:
1678 case PP_ELIFNUM:
1679 case PP_IFNNUM:
1680 case PP_ELIFNNUM:
1681 j = (t->type == TOK_NUMBER);
1682 break;
1683 case PP_IFSTR:
1684 case PP_ELIFSTR:
1685 case PP_IFNSTR:
1686 case PP_ELIFNSTR:
1687 j = (t->type == TOK_STRING);
1688 break;
1690 if (i == PP_IFNID || i == PP_ELIFNID ||
1691 i == PP_IFNNUM || i == PP_ELIFNNUM ||
1692 i == PP_IFNSTR || i == PP_ELIFNSTR)
1693 j = !j;
1694 free_tlist(tline);
1695 return j;
1697 case PP_IF:
1698 case PP_ELIF:
1699 t = tline = expand_smacro(tline);
1700 tptr = &t;
1701 tokval.t_type = TOKEN_INVALID;
1702 evalresult = evaluate(ppscan, tptr, &tokval,
1703 NULL, pass | CRITICAL, error, NULL);
1704 free_tlist(tline);
1705 if (!evalresult)
1706 return -1;
1707 if (tokval.t_type)
1708 error(ERR_WARNING,
1709 "trailing garbage after expression ignored");
1710 if (!is_simple(evalresult))
1712 error(ERR_NONFATAL,
1713 "non-constant value given to `%s'", directives[i]);
1714 return -1;
1716 return reloc_value(evalresult) != 0;
1718 default:
1719 error(ERR_FATAL,
1720 "preprocessor directive `%s' not yet implemented",
1721 directives[i]);
1722 free_tlist(origline);
1723 return -1; /* yeah, right */
1728 * Expand macros in a string. Used in %error and %include directives.
1729 * First tokenise the string, apply "expand_smacro" and then de-tokenise back.
1730 * The returned variable should ALWAYS be freed after usage.
1732 void
1733 expand_macros_in_string(char **p)
1735 Token *line = tokenise(*p);
1736 line = expand_smacro(line);
1737 *p = detoken(line, FALSE);
1741 * Find out if a line contains a preprocessor directive, and deal
1742 * with it if so.
1744 * If a directive _is_ found, we are expected to free_tlist() the
1745 * line.
1747 * Return values go like this:
1749 * bit 0 is set if a directive was found (so the line gets freed)
1751 static int
1752 do_directive(Token * tline)
1754 int i, j, k, m, nparam, nolist;
1755 int offset;
1756 char *p, *mname;
1757 Include *inc;
1758 Context *ctx;
1759 Cond *cond;
1760 SMacro *smac, **smhead;
1761 MMacro *mmac;
1762 Token *t, *tt, *param_start, *macro_start, *last, **tptr, *origline;
1763 Line *l;
1764 struct tokenval tokval;
1765 expr *evalresult;
1766 MMacro *tmp_defining; /* Used when manipulating rep_nest */
1768 origline = tline;
1770 skip_white_(tline);
1771 if (!tok_type_(tline, TOK_PREPROC_ID) ||
1772 (tline->text[1] == '%' || tline->text[1] == '$'
1773 || tline->text[1] == '!'))
1774 return 0;
1776 i = -1;
1777 j = sizeof(directives) / sizeof(*directives);
1778 while (j - i > 1)
1780 k = (j + i) / 2;
1781 m = nasm_stricmp(tline->text, directives[k]);
1782 if (m == 0) {
1783 if (tasm_compatible_mode) {
1784 i = k;
1785 j = -2;
1786 } else if (k != PP_ARG && k != PP_LOCAL && k != PP_STACKSIZE) {
1787 i = k;
1788 j = -2;
1790 break;
1792 else if (m < 0) {
1793 j = k;
1795 else
1796 i = k;
1800 * If we're in a non-emitting branch of a condition construct,
1801 * or walking to the end of an already terminated %rep block,
1802 * we should ignore all directives except for condition
1803 * directives.
1805 if (((istk->conds && !emitting(istk->conds->state)) ||
1806 (istk->mstk && !istk->mstk->in_progress)) &&
1807 !is_condition(i))
1809 return 0;
1813 * If we're defining a macro or reading a %rep block, we should
1814 * ignore all directives except for %macro/%imacro (which
1815 * generate an error), %endm/%endmacro, and (only if we're in a
1816 * %rep block) %endrep. If we're in a %rep block, another %rep
1817 * causes an error, so should be let through.
1819 if (defining && i != PP_MACRO && i != PP_IMACRO &&
1820 i != PP_ENDMACRO && i != PP_ENDM &&
1821 (defining->name || (i != PP_ENDREP && i != PP_REP)))
1823 return 0;
1826 if (j != -2)
1828 error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
1829 tline->text);
1830 return 0; /* didn't get it */
1833 switch (i)
1835 case PP_STACKSIZE:
1836 /* Directive to tell NASM what the default stack size is. The
1837 * default is for a 16-bit stack, and this can be overriden with
1838 * %stacksize large.
1839 * the following form:
1841 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1843 tline = tline->next;
1844 if (tline && tline->type == TOK_WHITESPACE)
1845 tline = tline->next;
1846 if (!tline || tline->type != TOK_ID)
1848 error(ERR_NONFATAL, "`%%stacksize' missing size parameter");
1849 free_tlist(origline);
1850 return 3;
1852 if (nasm_stricmp(tline->text, "flat") == 0)
1854 /* All subsequent ARG directives are for a 32-bit stack */
1855 StackSize = 4;
1856 StackPointer = "ebp";
1857 ArgOffset = 8;
1858 LocalOffset = 4;
1860 else if (nasm_stricmp(tline->text, "large") == 0)
1862 /* All subsequent ARG directives are for a 16-bit stack,
1863 * far function call.
1865 StackSize = 2;
1866 StackPointer = "bp";
1867 ArgOffset = 4;
1868 LocalOffset = 2;
1870 else if (nasm_stricmp(tline->text, "small") == 0)
1872 /* All subsequent ARG directives are for a 16-bit stack,
1873 * far function call. We don't support near functions.
1875 StackSize = 2;
1876 StackPointer = "bp";
1877 ArgOffset = 6;
1878 LocalOffset = 2;
1880 else
1882 error(ERR_NONFATAL, "`%%stacksize' invalid size type");
1883 free_tlist(origline);
1884 return 3;
1886 free_tlist(origline);
1887 return 3;
1889 case PP_ARG:
1890 /* TASM like ARG directive to define arguments to functions, in
1891 * the following form:
1893 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1895 offset = ArgOffset;
1898 char *arg, directive[256];
1899 int size = StackSize;
1901 /* Find the argument name */
1902 tline = tline->next;
1903 if (tline && tline->type == TOK_WHITESPACE)
1904 tline = tline->next;
1905 if (!tline || tline->type != TOK_ID)
1907 error(ERR_NONFATAL, "`%%arg' missing argument parameter");
1908 free_tlist(origline);
1909 return 3;
1911 arg = tline->text;
1913 /* Find the argument size type */
1914 tline = tline->next;
1915 if (!tline || tline->type != TOK_OTHER
1916 || tline->text[0] != ':')
1918 error(ERR_NONFATAL,
1919 "Syntax error processing `%%arg' directive");
1920 free_tlist(origline);
1921 return 3;
1923 tline = tline->next;
1924 if (!tline || tline->type != TOK_ID)
1926 error(ERR_NONFATAL,
1927 "`%%arg' missing size type parameter");
1928 free_tlist(origline);
1929 return 3;
1932 /* Allow macro expansion of type parameter */
1933 tt = tokenise(tline->text);
1934 tt = expand_smacro(tt);
1935 if (nasm_stricmp(tt->text, "byte") == 0)
1937 size = MAX(StackSize, 1);
1939 else if (nasm_stricmp(tt->text, "word") == 0)
1941 size = MAX(StackSize, 2);
1943 else if (nasm_stricmp(tt->text, "dword") == 0)
1945 size = MAX(StackSize, 4);
1947 else if (nasm_stricmp(tt->text, "qword") == 0)
1949 size = MAX(StackSize, 8);
1951 else if (nasm_stricmp(tt->text, "tword") == 0)
1953 size = MAX(StackSize, 10);
1955 else
1957 error(ERR_NONFATAL,
1958 "Invalid size type for `%%arg' missing directive");
1959 free_tlist(tt);
1960 free_tlist(origline);
1961 return 3;
1963 free_tlist(tt);
1965 /* Now define the macro for the argument */
1966 sprintf(directive, "%%define %s (%s+%d)", arg, StackPointer,
1967 offset);
1968 do_directive(tokenise(directive));
1969 offset += size;
1971 /* Move to the next argument in the list */
1972 tline = tline->next;
1973 if (tline && tline->type == TOK_WHITESPACE)
1974 tline = tline->next;
1976 while (tline && tline->type == TOK_OTHER
1977 && tline->text[0] == ',');
1978 free_tlist(origline);
1979 return 3;
1981 case PP_LOCAL:
1982 /* TASM like LOCAL directive to define local variables for a
1983 * function, in the following form:
1985 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
1987 * The '= LocalSize' at the end is ignored by NASM, but is
1988 * required by TASM to define the local parameter size (and used
1989 * by the TASM macro package).
1991 offset = LocalOffset;
1994 char *local, directive[256];
1995 int size = StackSize;
1997 /* Find the argument name */
1998 tline = tline->next;
1999 if (tline && tline->type == TOK_WHITESPACE)
2000 tline = tline->next;
2001 if (!tline || tline->type != TOK_ID)
2003 error(ERR_NONFATAL,
2004 "`%%local' missing argument parameter");
2005 free_tlist(origline);
2006 return 3;
2008 local = tline->text;
2010 /* Find the argument size type */
2011 tline = tline->next;
2012 if (!tline || tline->type != TOK_OTHER
2013 || tline->text[0] != ':')
2015 error(ERR_NONFATAL,
2016 "Syntax error processing `%%local' directive");
2017 free_tlist(origline);
2018 return 3;
2020 tline = tline->next;
2021 if (!tline || tline->type != TOK_ID)
2023 error(ERR_NONFATAL,
2024 "`%%local' missing size type parameter");
2025 free_tlist(origline);
2026 return 3;
2029 /* Allow macro expansion of type parameter */
2030 tt = tokenise(tline->text);
2031 tt = expand_smacro(tt);
2032 if (nasm_stricmp(tt->text, "byte") == 0)
2034 size = MAX(StackSize, 1);
2036 else if (nasm_stricmp(tt->text, "word") == 0)
2038 size = MAX(StackSize, 2);
2040 else if (nasm_stricmp(tt->text, "dword") == 0)
2042 size = MAX(StackSize, 4);
2044 else if (nasm_stricmp(tt->text, "qword") == 0)
2046 size = MAX(StackSize, 8);
2048 else if (nasm_stricmp(tt->text, "tword") == 0)
2050 size = MAX(StackSize, 10);
2052 else
2054 error(ERR_NONFATAL,
2055 "Invalid size type for `%%local' missing directive");
2056 free_tlist(tt);
2057 free_tlist(origline);
2058 return 3;
2060 free_tlist(tt);
2062 /* Now define the macro for the argument */
2063 sprintf(directive, "%%define %s (%s-%d)", local, StackPointer,
2064 offset);
2065 do_directive(tokenise(directive));
2066 offset += size;
2068 /* Now define the assign to setup the enter_c macro correctly */
2069 sprintf(directive, "%%assign %%$localsize %%$localsize+%d",
2070 size);
2071 do_directive(tokenise(directive));
2073 /* Move to the next argument in the list */
2074 tline = tline->next;
2075 if (tline && tline->type == TOK_WHITESPACE)
2076 tline = tline->next;
2078 while (tline && tline->type == TOK_OTHER
2079 && tline->text[0] == ',');
2080 free_tlist(origline);
2081 return 3;
2083 case PP_CLEAR:
2084 if (tline->next)
2085 error(ERR_WARNING,
2086 "trailing garbage after `%%clear' ignored");
2087 for (j = 0; j < NHASH; j++)
2089 while (mmacros[j])
2091 MMacro *m = mmacros[j];
2092 mmacros[j] = m->next;
2093 free_mmacro(m);
2095 while (smacros[j])
2097 SMacro *s = smacros[j];
2098 smacros[j] = smacros[j]->next;
2099 nasm_free(s->name);
2100 free_tlist(s->expansion);
2101 nasm_free(s);
2104 free_tlist(origline);
2105 return 3;
2107 case PP_INCLUDE:
2108 tline = tline->next;
2109 skip_white_(tline);
2110 if (!tline || (tline->type != TOK_STRING &&
2111 tline->type != TOK_INTERNAL_STRING))
2113 error(ERR_NONFATAL, "`%%include' expects a file name");
2114 free_tlist(origline);
2115 return 3; /* but we did _something_ */
2117 if (tline->next)
2118 error(ERR_WARNING,
2119 "trailing garbage after `%%include' ignored");
2120 if (tline->type != TOK_INTERNAL_STRING)
2122 p = tline->text + 1; /* point past the quote to the name */
2123 p[strlen(p) - 1] = '\0'; /* remove the trailing quote */
2125 else
2126 p = tline->text; /* internal_string is easier */
2127 expand_macros_in_string(&p);
2128 inc = nasm_malloc(sizeof(Include));
2129 inc->next = istk;
2130 inc->conds = NULL;
2131 inc->fp = inc_fopen(p);
2132 inc->fname = src_set_fname(p);
2133 inc->lineno = src_set_linnum(0);
2134 inc->lineinc = 1;
2135 inc->expansion = NULL;
2136 inc->mstk = NULL;
2137 istk = inc;
2138 list->uplevel(LIST_INCLUDE);
2139 free_tlist(origline);
2140 return 5;
2142 case PP_PUSH:
2143 tline = tline->next;
2144 skip_white_(tline);
2145 tline = expand_id(tline);
2146 if (!tok_type_(tline, TOK_ID))
2148 error(ERR_NONFATAL, "`%%push' expects a context identifier");
2149 free_tlist(origline);
2150 return 3; /* but we did _something_ */
2152 if (tline->next)
2153 error(ERR_WARNING, "trailing garbage after `%%push' ignored");
2154 ctx = nasm_malloc(sizeof(Context));
2155 ctx->next = cstk;
2156 ctx->localmac = NULL;
2157 ctx->name = nasm_strdup(tline->text);
2158 ctx->number = unique++;
2159 cstk = ctx;
2160 free_tlist(origline);
2161 break;
2163 case PP_REPL:
2164 tline = tline->next;
2165 skip_white_(tline);
2166 tline = expand_id(tline);
2167 if (!tok_type_(tline, TOK_ID))
2169 error(ERR_NONFATAL, "`%%repl' expects a context identifier");
2170 free_tlist(origline);
2171 return 3; /* but we did _something_ */
2173 if (tline->next)
2174 error(ERR_WARNING, "trailing garbage after `%%repl' ignored");
2175 if (!cstk)
2176 error(ERR_NONFATAL, "`%%repl': context stack is empty");
2177 else
2179 nasm_free(cstk->name);
2180 cstk->name = nasm_strdup(tline->text);
2182 free_tlist(origline);
2183 break;
2185 case PP_POP:
2186 if (tline->next)
2187 error(ERR_WARNING, "trailing garbage after `%%pop' ignored");
2188 if (!cstk)
2189 error(ERR_NONFATAL,
2190 "`%%pop': context stack is already empty");
2191 else
2192 ctx_pop();
2193 free_tlist(origline);
2194 break;
2196 case PP_ERROR:
2197 tline->next = expand_smacro(tline->next);
2198 tline = tline->next;
2199 skip_white_(tline);
2200 if (tok_type_(tline, TOK_STRING))
2202 p = tline->text + 1; /* point past the quote to the name */
2203 p[strlen(p) - 1] = '\0'; /* remove the trailing quote */
2204 expand_macros_in_string(&p);
2205 error(ERR_NONFATAL, "%s", p);
2206 nasm_free(p);
2208 else
2210 p = detoken(tline, FALSE);
2211 error(ERR_WARNING, "%s", p);
2212 nasm_free(p);
2214 free_tlist(origline);
2215 break;
2217 case PP_IF:
2218 case PP_IFCTX:
2219 case PP_IFDEF:
2220 case PP_IFID:
2221 case PP_IFIDN:
2222 case PP_IFIDNI:
2223 case PP_IFMACRO:
2224 case PP_IFNCTX:
2225 case PP_IFNDEF:
2226 case PP_IFNID:
2227 case PP_IFNIDN:
2228 case PP_IFNIDNI:
2229 case PP_IFNMACRO:
2230 case PP_IFNNUM:
2231 case PP_IFNSTR:
2232 case PP_IFNUM:
2233 case PP_IFSTR:
2234 if (istk->conds && !emitting(istk->conds->state))
2235 j = COND_NEVER;
2236 else
2238 j = if_condition(tline->next, i);
2239 tline->next = NULL; /* it got freed */
2240 free_tlist(origline);
2241 j = j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2243 cond = nasm_malloc(sizeof(Cond));
2244 cond->next = istk->conds;
2245 cond->state = j;
2246 istk->conds = cond;
2247 return (j == COND_IF_TRUE ? 3 : 1);
2249 case PP_ELIF:
2250 case PP_ELIFCTX:
2251 case PP_ELIFDEF:
2252 case PP_ELIFID:
2253 case PP_ELIFIDN:
2254 case PP_ELIFIDNI:
2255 case PP_ELIFMACRO:
2256 case PP_ELIFNCTX:
2257 case PP_ELIFNDEF:
2258 case PP_ELIFNID:
2259 case PP_ELIFNIDN:
2260 case PP_ELIFNIDNI:
2261 case PP_ELIFNMACRO:
2262 case PP_ELIFNNUM:
2263 case PP_ELIFNSTR:
2264 case PP_ELIFNUM:
2265 case PP_ELIFSTR:
2266 if (!istk->conds)
2267 error(ERR_FATAL, "`%s': no matching `%%if'", directives[i]);
2268 if (emitting(istk->conds->state)
2269 || istk->conds->state == COND_NEVER)
2270 istk->conds->state = COND_NEVER;
2271 else
2274 * IMPORTANT: In the case of %if, we will already have
2275 * called expand_mmac_params(); however, if we're
2276 * processing an %elif we must have been in a
2277 * non-emitting mode, which would have inhibited
2278 * the normal invocation of expand_mmac_params(). Therefore,
2279 * we have to do it explicitly here.
2281 j = if_condition(expand_mmac_params(tline->next), i);
2282 tline->next = NULL; /* it got freed */
2283 free_tlist(origline);
2284 istk->conds->state =
2285 j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2287 return (istk->conds->state == COND_IF_TRUE ? 5 : 1);
2289 case PP_ELSE:
2290 if (tline->next)
2291 error(ERR_WARNING, "trailing garbage after `%%else' ignored");
2292 if (!istk->conds)
2293 error(ERR_FATAL, "`%%else': no matching `%%if'");
2294 if (emitting(istk->conds->state)
2295 || istk->conds->state == COND_NEVER)
2296 istk->conds->state = COND_ELSE_FALSE;
2297 else
2298 istk->conds->state = COND_ELSE_TRUE;
2299 free_tlist(origline);
2300 return 5;
2302 case PP_ENDIF:
2303 if (tline->next)
2304 error(ERR_WARNING,
2305 "trailing garbage after `%%endif' ignored");
2306 if (!istk->conds)
2307 error(ERR_FATAL, "`%%endif': no matching `%%if'");
2308 cond = istk->conds;
2309 istk->conds = cond->next;
2310 nasm_free(cond);
2311 free_tlist(origline);
2312 return 5;
2314 case PP_MACRO:
2315 case PP_IMACRO:
2316 if (defining)
2317 error(ERR_FATAL,
2318 "`%%%smacro': already defining a macro",
2319 (i == PP_IMACRO ? "i" : ""));
2320 tline = tline->next;
2321 skip_white_(tline);
2322 tline = expand_id(tline);
2323 if (!tok_type_(tline, TOK_ID))
2325 error(ERR_NONFATAL,
2326 "`%%%smacro' expects a macro name",
2327 (i == PP_IMACRO ? "i" : ""));
2328 return 3;
2330 defining = nasm_malloc(sizeof(MMacro));
2331 defining->name = nasm_strdup(tline->text);
2332 defining->casesense = (i == PP_MACRO);
2333 defining->plus = FALSE;
2334 defining->nolist = FALSE;
2335 defining->in_progress = FALSE;
2336 defining->rep_nest = NULL;
2337 tline = expand_smacro(tline->next);
2338 skip_white_(tline);
2339 if (!tok_type_(tline, TOK_NUMBER))
2341 error(ERR_NONFATAL,
2342 "`%%%smacro' expects a parameter count",
2343 (i == PP_IMACRO ? "i" : ""));
2344 defining->nparam_min = defining->nparam_max = 0;
2346 else
2348 defining->nparam_min = defining->nparam_max =
2349 readnum(tline->text, &j);
2350 if (j)
2351 error(ERR_NONFATAL,
2352 "unable to parse parameter count `%s'",
2353 tline->text);
2355 if (tline && tok_is_(tline->next, "-"))
2357 tline = tline->next->next;
2358 if (tok_is_(tline, "*"))
2359 defining->nparam_max = INT_MAX;
2360 else if (!tok_type_(tline, TOK_NUMBER))
2361 error(ERR_NONFATAL,
2362 "`%%%smacro' expects a parameter count after `-'",
2363 (i == PP_IMACRO ? "i" : ""));
2364 else
2366 defining->nparam_max = readnum(tline->text, &j);
2367 if (j)
2368 error(ERR_NONFATAL,
2369 "unable to parse parameter count `%s'",
2370 tline->text);
2371 if (defining->nparam_min > defining->nparam_max)
2372 error(ERR_NONFATAL,
2373 "minimum parameter count exceeds maximum");
2376 if (tline && tok_is_(tline->next, "+"))
2378 tline = tline->next;
2379 defining->plus = TRUE;
2381 if (tline && tok_type_(tline->next, TOK_ID) &&
2382 !nasm_stricmp(tline->next->text, ".nolist"))
2384 tline = tline->next;
2385 defining->nolist = TRUE;
2387 mmac = mmacros[hash(defining->name)];
2388 while (mmac)
2390 if (!strcmp(mmac->name, defining->name) &&
2391 (mmac->nparam_min <= defining->nparam_max
2392 || defining->plus)
2393 && (defining->nparam_min <= mmac->nparam_max
2394 || mmac->plus))
2396 error(ERR_WARNING,
2397 "redefining multi-line macro `%s'",
2398 defining->name);
2399 break;
2401 mmac = mmac->next;
2404 * Handle default parameters.
2406 if (tline && tline->next)
2408 defining->dlist = tline->next;
2409 tline->next = NULL;
2410 count_mmac_params(defining->dlist, &defining->ndefs,
2411 &defining->defaults);
2413 else
2415 defining->dlist = NULL;
2416 defining->defaults = NULL;
2418 defining->expansion = NULL;
2419 free_tlist(origline);
2420 return 1;
2422 case PP_ENDM:
2423 case PP_ENDMACRO:
2424 if (!defining)
2426 error(ERR_NONFATAL, "`%s': not defining a macro",
2427 tline->text);
2428 return 3;
2430 k = hash(defining->name);
2431 defining->next = mmacros[k];
2432 mmacros[k] = defining;
2433 defining = NULL;
2434 free_tlist(origline);
2435 return 5;
2437 case PP_ROTATE:
2438 if (tline->next && tline->next->type == TOK_WHITESPACE)
2439 tline = tline->next;
2440 t = expand_smacro(tline->next);
2441 tline->next = NULL;
2442 free_tlist(origline);
2443 tline = t;
2444 tptr = &t;
2445 tokval.t_type = TOKEN_INVALID;
2446 evalresult =
2447 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2448 free_tlist(tline);
2449 if (!evalresult)
2450 return 3;
2451 if (tokval.t_type)
2452 error(ERR_WARNING,
2453 "trailing garbage after expression ignored");
2454 if (!is_simple(evalresult))
2456 error(ERR_NONFATAL, "non-constant value given to `%%rotate'");
2457 return 3;
2459 mmac = istk->mstk;
2460 while (mmac && !mmac->name) /* avoid mistaking %reps for macros */
2461 mmac = mmac->next_active;
2462 if (!mmac)
2463 error(ERR_NONFATAL,
2464 "`%%rotate' invoked outside a macro call");
2465 mmac->rotate = mmac->rotate + reloc_value(evalresult);
2466 if (mmac->rotate < 0)
2467 mmac->rotate = mmac->nparam - (-mmac->rotate) % mmac->nparam;
2468 mmac->rotate %= mmac->nparam;
2469 return 1;
2471 case PP_REP:
2472 nolist = FALSE;
2473 tline = tline->next;
2474 if (tline->next && tline->next->type == TOK_WHITESPACE)
2475 tline = tline->next;
2476 if (tline->next && tline->next->type == TOK_ID &&
2477 !nasm_stricmp(tline->next->text, ".nolist"))
2479 tline = tline->next;
2480 nolist = TRUE;
2482 t = expand_smacro(tline->next);
2483 tline->next = NULL;
2484 free_tlist(origline);
2485 tline = t;
2486 tptr = &t;
2487 tokval.t_type = TOKEN_INVALID;
2488 evalresult =
2489 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2490 free_tlist(tline);
2491 if (!evalresult)
2492 return 3;
2493 if (tokval.t_type)
2494 error(ERR_WARNING,
2495 "trailing garbage after expression ignored");
2496 if (!is_simple(evalresult))
2498 error(ERR_NONFATAL, "non-constant value given to `%%rep'");
2499 return 3;
2501 tmp_defining = defining;
2502 defining = nasm_malloc(sizeof(MMacro));
2503 defining->name = NULL; /* flags this macro as a %rep block */
2504 defining->casesense = 0;
2505 defining->plus = FALSE;
2506 defining->nolist = nolist;
2507 defining->in_progress = reloc_value(evalresult) + 1;
2508 defining->nparam_min = defining->nparam_max = 0;
2509 defining->defaults = NULL;
2510 defining->dlist = NULL;
2511 defining->expansion = NULL;
2512 defining->next_active = istk->mstk;
2513 defining->rep_nest = tmp_defining;
2514 return 1;
2516 case PP_ENDREP:
2517 if (!defining || defining->name)
2519 error(ERR_NONFATAL, "`%%endrep': no matching `%%rep'");
2520 return 3;
2524 * Now we have a "macro" defined - although it has no name
2525 * and we won't be entering it in the hash tables - we must
2526 * push a macro-end marker for it on to istk->expansion.
2527 * After that, it will take care of propagating itself (a
2528 * macro-end marker line for a macro which is really a %rep
2529 * block will cause the macro to be re-expanded, complete
2530 * with another macro-end marker to ensure the process
2531 * continues) until the whole expansion is forcibly removed
2532 * from istk->expansion by a %exitrep.
2534 l = nasm_malloc(sizeof(Line));
2535 l->next = istk->expansion;
2536 l->finishes = defining;
2537 l->first = NULL;
2538 istk->expansion = l;
2540 istk->mstk = defining;
2542 list->uplevel(defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
2543 tmp_defining = defining;
2544 defining = defining->rep_nest;
2545 free_tlist(origline);
2546 return 1;
2548 case PP_EXITREP:
2550 * We must search along istk->expansion until we hit a
2551 * macro-end marker for a macro with no name. Then we set
2552 * its `in_progress' flag to 0.
2554 for (l = istk->expansion; l; l = l->next)
2555 if (l->finishes && !l->finishes->name)
2556 break;
2558 if (l)
2559 l->finishes->in_progress = 0;
2560 else
2561 error(ERR_NONFATAL, "`%%exitrep' not within `%%rep' block");
2562 free_tlist(origline);
2563 return 1;
2565 case PP_XDEFINE:
2566 case PP_IXDEFINE:
2567 case PP_DEFINE:
2568 case PP_IDEFINE:
2569 tline = tline->next;
2570 skip_white_(tline);
2571 tline = expand_id(tline);
2572 if (!tline || (tline->type != TOK_ID &&
2573 (tline->type != TOK_PREPROC_ID ||
2574 tline->text[1] != '$')))
2576 error(ERR_NONFATAL,
2577 "`%%%s%sdefine' expects a macro identifier",
2578 ((i == PP_IDEFINE || i == PP_IXDEFINE) ? "i" : ""),
2579 ((i == PP_XDEFINE || i == PP_IXDEFINE) ? "x" : ""));
2580 free_tlist(origline);
2581 return 3;
2584 ctx = get_ctx(tline->text, FALSE);
2585 if (!ctx)
2586 smhead = &smacros[hash(tline->text)];
2587 else
2588 smhead = &ctx->localmac;
2589 mname = tline->text;
2590 last = tline;
2591 param_start = tline = tline->next;
2592 nparam = 0;
2594 /* Expand the macro definition now for %xdefine and %ixdefine */
2595 if ((i == PP_XDEFINE) || (i == PP_IXDEFINE))
2596 tline = expand_smacro(tline);
2598 if (tok_is_(tline, "("))
2601 * This macro has parameters.
2604 tline = tline->next;
2605 while (1)
2607 skip_white_(tline);
2608 if (!tline)
2610 error(ERR_NONFATAL, "parameter identifier expected");
2611 free_tlist(origline);
2612 return 3;
2614 if (tline->type != TOK_ID)
2616 error(ERR_NONFATAL,
2617 "`%s': parameter identifier expected",
2618 tline->text);
2619 free_tlist(origline);
2620 return 3;
2622 tline->type = TOK_SMAC_PARAM + nparam++;
2623 tline = tline->next;
2624 skip_white_(tline);
2625 if (tok_is_(tline, ","))
2627 tline = tline->next;
2628 continue;
2630 if (!tok_is_(tline, ")"))
2632 error(ERR_NONFATAL,
2633 "`)' expected to terminate macro template");
2634 free_tlist(origline);
2635 return 3;
2637 break;
2639 last = tline;
2640 tline = tline->next;
2642 if (tok_type_(tline, TOK_WHITESPACE))
2643 last = tline, tline = tline->next;
2644 macro_start = NULL;
2645 last->next = NULL;
2646 t = tline;
2647 while (t)
2649 if (t->type == TOK_ID)
2651 for (tt = param_start; tt; tt = tt->next)
2652 if (tt->type >= TOK_SMAC_PARAM &&
2653 !strcmp(tt->text, t->text))
2654 t->type = tt->type;
2656 tt = t->next;
2657 t->next = macro_start;
2658 macro_start = t;
2659 t = tt;
2662 * Good. We now have a macro name, a parameter count, and a
2663 * token list (in reverse order) for an expansion. We ought
2664 * to be OK just to create an SMacro, store it, and let
2665 * free_tlist have the rest of the line (which we have
2666 * carefully re-terminated after chopping off the expansion
2667 * from the end).
2669 if (smacro_defined(ctx, mname, nparam, &smac, i == PP_DEFINE))
2671 if (!smac)
2673 error(ERR_WARNING,
2674 "single-line macro `%s' defined both with and"
2675 " without parameters", mname);
2676 free_tlist(origline);
2677 free_tlist(macro_start);
2678 return 3;
2680 else
2683 * We're redefining, so we have to take over an
2684 * existing SMacro structure. This means freeing
2685 * what was already in it.
2687 nasm_free(smac->name);
2688 free_tlist(smac->expansion);
2691 else
2693 smac = nasm_malloc(sizeof(SMacro));
2694 smac->next = *smhead;
2695 *smhead = smac;
2697 smac->name = nasm_strdup(mname);
2698 smac->casesense = ((i == PP_DEFINE) || (i == PP_XDEFINE));
2699 smac->nparam = nparam;
2700 smac->expansion = macro_start;
2701 smac->in_progress = FALSE;
2702 free_tlist(origline);
2703 return 3;
2705 case PP_UNDEF:
2706 tline = tline->next;
2707 skip_white_(tline);
2708 tline = expand_id(tline);
2709 if (!tline || (tline->type != TOK_ID &&
2710 (tline->type != TOK_PREPROC_ID ||
2711 tline->text[1] != '$')))
2713 error(ERR_NONFATAL, "`%%undef' expects a macro identifier");
2714 free_tlist(origline);
2715 return 3;
2717 if (tline->next)
2719 error(ERR_WARNING,
2720 "trailing garbage after macro name ignored");
2723 /* Find the context that symbol belongs to */
2724 ctx = get_ctx(tline->text, FALSE);
2725 if (!ctx)
2726 smhead = &smacros[hash(tline->text)];
2727 else
2728 smhead = &ctx->localmac;
2730 mname = tline->text;
2731 last = tline;
2732 last->next = NULL;
2735 * We now have a macro name... go hunt for it.
2737 while (smacro_defined(ctx, mname, -1, &smac, 1))
2739 /* Defined, so we need to find its predecessor and nuke it */
2740 SMacro **s;
2741 for (s = smhead; *s && *s != smac; s = &(*s)->next);
2742 if (*s)
2744 *s = smac->next;
2745 nasm_free(smac->name);
2746 free_tlist(smac->expansion);
2747 nasm_free(smac);
2750 free_tlist(origline);
2751 return 3;
2753 case PP_STRLEN:
2754 tline = tline->next;
2755 skip_white_(tline);
2756 tline = expand_id(tline);
2757 if (!tline || (tline->type != TOK_ID &&
2758 (tline->type != TOK_PREPROC_ID ||
2759 tline->text[1] != '$')))
2761 error(ERR_NONFATAL,
2762 "`%%strlen' expects a macro identifier as first parameter");
2763 free_tlist(origline);
2764 return 3;
2766 ctx = get_ctx(tline->text, FALSE);
2767 if (!ctx)
2768 smhead = &smacros[hash(tline->text)];
2769 else
2770 smhead = &ctx->localmac;
2771 mname = tline->text;
2772 last = tline;
2773 tline = expand_smacro(tline->next);
2774 last->next = NULL;
2776 t = tline;
2777 while (tok_type_(t, TOK_WHITESPACE))
2778 t = t->next;
2779 /* t should now point to the string */
2780 if (t->type != TOK_STRING)
2782 error(ERR_NONFATAL,
2783 "`%%strlen` requires string as second parameter");
2784 free_tlist(tline);
2785 free_tlist(origline);
2786 return 3;
2789 macro_start = nasm_malloc(sizeof(*macro_start));
2790 macro_start->next = NULL;
2791 make_tok_num(macro_start, strlen(t->text) - 2);
2792 macro_start->mac = NULL;
2795 * We now have a macro name, an implicit parameter count of
2796 * zero, and a numeric token to use as an expansion. Create
2797 * and store an SMacro.
2799 if (smacro_defined(ctx, mname, 0, &smac, i == PP_STRLEN))
2801 if (!smac)
2802 error(ERR_WARNING,
2803 "single-line macro `%s' defined both with and"
2804 " without parameters", mname);
2805 else
2808 * We're redefining, so we have to take over an
2809 * existing SMacro structure. This means freeing
2810 * what was already in it.
2812 nasm_free(smac->name);
2813 free_tlist(smac->expansion);
2816 else
2818 smac = nasm_malloc(sizeof(SMacro));
2819 smac->next = *smhead;
2820 *smhead = smac;
2822 smac->name = nasm_strdup(mname);
2823 smac->casesense = (i == PP_STRLEN);
2824 smac->nparam = 0;
2825 smac->expansion = macro_start;
2826 smac->in_progress = FALSE;
2827 free_tlist(tline);
2828 free_tlist(origline);
2829 return 3;
2831 case PP_SUBSTR:
2832 tline = tline->next;
2833 skip_white_(tline);
2834 tline = expand_id(tline);
2835 if (!tline || (tline->type != TOK_ID &&
2836 (tline->type != TOK_PREPROC_ID ||
2837 tline->text[1] != '$')))
2839 error(ERR_NONFATAL,
2840 "`%%substr' expects a macro identifier as first parameter");
2841 free_tlist(origline);
2842 return 3;
2844 ctx = get_ctx(tline->text, FALSE);
2845 if (!ctx)
2846 smhead = &smacros[hash(tline->text)];
2847 else
2848 smhead = &ctx->localmac;
2849 mname = tline->text;
2850 last = tline;
2851 tline = expand_smacro(tline->next);
2852 last->next = NULL;
2854 t = tline->next;
2855 while (tok_type_(t, TOK_WHITESPACE))
2856 t = t->next;
2858 /* t should now point to the string */
2859 if (t->type != TOK_STRING)
2861 error(ERR_NONFATAL,
2862 "`%%substr` requires string as second parameter");
2863 free_tlist(tline);
2864 free_tlist(origline);
2865 return 3;
2868 tt = t->next;
2869 tptr = &tt;
2870 tokval.t_type = TOKEN_INVALID;
2871 evalresult =
2872 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2873 if (!evalresult)
2875 free_tlist(tline);
2876 free_tlist(origline);
2877 return 3;
2879 if (!is_simple(evalresult))
2881 error(ERR_NONFATAL, "non-constant value given to `%%substr`");
2882 free_tlist(tline);
2883 free_tlist(origline);
2884 return 3;
2887 macro_start = nasm_malloc(sizeof(*macro_start));
2888 macro_start->next = NULL;
2889 macro_start->text = nasm_strdup("'''");
2890 if (evalresult->value > 0
2891 && evalresult->value < strlen(t->text) - 1)
2893 macro_start->text[1] = t->text[evalresult->value];
2895 else
2897 macro_start->text[2] = '\0';
2899 macro_start->type = TOK_STRING;
2900 macro_start->mac = NULL;
2903 * We now have a macro name, an implicit parameter count of
2904 * zero, and a numeric token to use as an expansion. Create
2905 * and store an SMacro.
2907 if (smacro_defined(ctx, mname, 0, &smac, i == PP_SUBSTR))
2909 if (!smac)
2910 error(ERR_WARNING,
2911 "single-line macro `%s' defined both with and"
2912 " without parameters", mname);
2913 else
2916 * We're redefining, so we have to take over an
2917 * existing SMacro structure. This means freeing
2918 * what was already in it.
2920 nasm_free(smac->name);
2921 free_tlist(smac->expansion);
2924 else
2926 smac = nasm_malloc(sizeof(SMacro));
2927 smac->next = *smhead;
2928 *smhead = smac;
2930 smac->name = nasm_strdup(mname);
2931 smac->casesense = (i == PP_SUBSTR);
2932 smac->nparam = 0;
2933 smac->expansion = macro_start;
2934 smac->in_progress = FALSE;
2935 free_tlist(tline);
2936 free_tlist(origline);
2937 return 3;
2940 case PP_ASSIGN:
2941 case PP_IASSIGN:
2942 tline = tline->next;
2943 skip_white_(tline);
2944 tline = expand_id(tline);
2945 if (!tline || (tline->type != TOK_ID &&
2946 (tline->type != TOK_PREPROC_ID ||
2947 tline->text[1] != '$')))
2949 error(ERR_NONFATAL,
2950 "`%%%sassign' expects a macro identifier",
2951 (i == PP_IASSIGN ? "i" : ""));
2952 free_tlist(origline);
2953 return 3;
2955 ctx = get_ctx(tline->text, FALSE);
2956 if (!ctx)
2957 smhead = &smacros[hash(tline->text)];
2958 else
2959 smhead = &ctx->localmac;
2960 mname = tline->text;
2961 last = tline;
2962 tline = expand_smacro(tline->next);
2963 last->next = NULL;
2965 t = tline;
2966 tptr = &t;
2967 tokval.t_type = TOKEN_INVALID;
2968 evalresult =
2969 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2970 free_tlist(tline);
2971 if (!evalresult)
2973 free_tlist(origline);
2974 return 3;
2977 if (tokval.t_type)
2978 error(ERR_WARNING,
2979 "trailing garbage after expression ignored");
2981 if (!is_simple(evalresult))
2983 error(ERR_NONFATAL,
2984 "non-constant value given to `%%%sassign'",
2985 (i == PP_IASSIGN ? "i" : ""));
2986 free_tlist(origline);
2987 return 3;
2990 macro_start = nasm_malloc(sizeof(*macro_start));
2991 macro_start->next = NULL;
2992 make_tok_num(macro_start, reloc_value(evalresult));
2993 macro_start->mac = NULL;
2996 * We now have a macro name, an implicit parameter count of
2997 * zero, and a numeric token to use as an expansion. Create
2998 * and store an SMacro.
3000 if (smacro_defined(ctx, mname, 0, &smac, i == PP_ASSIGN))
3002 if (!smac)
3003 error(ERR_WARNING,
3004 "single-line macro `%s' defined both with and"
3005 " without parameters", mname);
3006 else
3009 * We're redefining, so we have to take over an
3010 * existing SMacro structure. This means freeing
3011 * what was already in it.
3013 nasm_free(smac->name);
3014 free_tlist(smac->expansion);
3017 else
3019 smac = nasm_malloc(sizeof(SMacro));
3020 smac->next = *smhead;
3021 *smhead = smac;
3023 smac->name = nasm_strdup(mname);
3024 smac->casesense = (i == PP_ASSIGN);
3025 smac->nparam = 0;
3026 smac->expansion = macro_start;
3027 smac->in_progress = FALSE;
3028 free_tlist(origline);
3029 return 3;
3031 case PP_LINE:
3033 * Syntax is `%line nnn[+mmm] [filename]'
3035 tline = tline->next;
3036 skip_white_(tline);
3037 if (!tok_type_(tline, TOK_NUMBER))
3039 error(ERR_NONFATAL, "`%%line' expects line number");
3040 free_tlist(origline);
3041 return 3;
3043 k = readnum(tline->text, &j);
3044 m = 1;
3045 tline = tline->next;
3046 if (tok_is_(tline, "+"))
3048 tline = tline->next;
3049 if (!tok_type_(tline, TOK_NUMBER))
3051 error(ERR_NONFATAL, "`%%line' expects line increment");
3052 free_tlist(origline);
3053 return 3;
3055 m = readnum(tline->text, &j);
3056 tline = tline->next;
3058 skip_white_(tline);
3059 src_set_linnum(k);
3060 istk->lineinc = m;
3061 if (tline)
3063 nasm_free(src_set_fname(detoken(tline, FALSE)));
3065 free_tlist(origline);
3066 return 5;
3068 default:
3069 error(ERR_FATAL,
3070 "preprocessor directive `%s' not yet implemented",
3071 directives[i]);
3072 break;
3074 return 3;
3078 * Ensure that a macro parameter contains a condition code and
3079 * nothing else. Return the condition code index if so, or -1
3080 * otherwise.
3082 static int
3083 find_cc(Token * t)
3085 Token *tt;
3086 int i, j, k, m;
3088 skip_white_(t);
3089 if (t->type != TOK_ID)
3090 return -1;
3091 tt = t->next;
3092 skip_white_(tt);
3093 if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
3094 return -1;
3096 i = -1;
3097 j = sizeof(conditions) / sizeof(*conditions);
3098 while (j - i > 1)
3100 k = (j + i) / 2;
3101 m = nasm_stricmp(t->text, conditions[k]);
3102 if (m == 0)
3104 i = k;
3105 j = -2;
3106 break;
3108 else if (m < 0)
3110 j = k;
3112 else
3113 i = k;
3115 if (j != -2)
3116 return -1;
3117 return i;
3121 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3122 * %-n) and MMacro-local identifiers (%%foo).
3124 static Token *
3125 expand_mmac_params(Token * tline)
3127 Token *t, *tt, **tail, *thead;
3129 tail = &thead;
3130 thead = NULL;
3132 while (tline)
3134 if (tline->type == TOK_PREPROC_ID &&
3135 (((tline->text[1] == '+' || tline->text[1] == '-')
3136 && tline->text[2]) || tline->text[1] == '%'
3137 || (tline->text[1] >= '0' && tline->text[1] <= '9')))
3139 char *text = NULL;
3140 int type = 0, cc; /* type = 0 to placate optimisers */
3141 char tmpbuf[30];
3142 int n, i;
3143 MMacro *mac;
3145 t = tline;
3146 tline = tline->next;
3148 mac = istk->mstk;
3149 while (mac && !mac->name) /* avoid mistaking %reps for macros */
3150 mac = mac->next_active;
3151 if (!mac)
3152 error(ERR_NONFATAL, "`%s': not in a macro call", t->text);
3153 else
3154 switch (t->text[1])
3157 * We have to make a substitution of one of the
3158 * forms %1, %-1, %+1, %%foo, %0.
3160 case '0':
3161 type = TOK_NUMBER;
3162 sprintf(tmpbuf, "%d", mac->nparam);
3163 text = nasm_strdup(tmpbuf);
3164 break;
3165 case '%':
3166 type = TOK_ID;
3167 sprintf(tmpbuf, "..@%lu.", mac->unique);
3168 text = nasm_strcat(tmpbuf, t->text + 2);
3169 break;
3170 case '-':
3171 n = atoi(t->text + 2) - 1;
3172 if (n >= mac->nparam)
3173 tt = NULL;
3174 else
3176 if (mac->nparam > 1)
3177 n = (n + mac->rotate) % mac->nparam;
3178 tt = mac->params[n];
3180 cc = find_cc(tt);
3181 if (cc == -1)
3183 error(ERR_NONFATAL,
3184 "macro parameter %d is not a condition code",
3185 n + 1);
3186 text = NULL;
3188 else
3190 type = TOK_ID;
3191 if (inverse_ccs[cc] == -1)
3193 error(ERR_NONFATAL,
3194 "condition code `%s' is not invertible",
3195 conditions[cc]);
3196 text = NULL;
3198 else
3199 text =
3200 nasm_strdup(conditions[inverse_ccs
3201 [cc]]);
3203 break;
3204 case '+':
3205 n = atoi(t->text + 2) - 1;
3206 if (n >= mac->nparam)
3207 tt = NULL;
3208 else
3210 if (mac->nparam > 1)
3211 n = (n + mac->rotate) % mac->nparam;
3212 tt = mac->params[n];
3214 cc = find_cc(tt);
3215 if (cc == -1)
3217 error(ERR_NONFATAL,
3218 "macro parameter %d is not a condition code",
3219 n + 1);
3220 text = NULL;
3222 else
3224 type = TOK_ID;
3225 text = nasm_strdup(conditions[cc]);
3227 break;
3228 default:
3229 n = atoi(t->text + 1) - 1;
3230 if (n >= mac->nparam)
3231 tt = NULL;
3232 else
3234 if (mac->nparam > 1)
3235 n = (n + mac->rotate) % mac->nparam;
3236 tt = mac->params[n];
3238 if (tt)
3240 for (i = 0; i < mac->paramlen[n]; i++)
3242 *tail =
3243 new_Token(NULL, tt->type, tt->text,
3245 tail = &(*tail)->next;
3246 tt = tt->next;
3249 text = NULL; /* we've done it here */
3250 break;
3252 if (!text)
3254 delete_Token(t);
3256 else
3258 *tail = t;
3259 tail = &t->next;
3260 t->type = type;
3261 nasm_free(t->text);
3262 t->text = text;
3263 t->mac = NULL;
3265 continue;
3267 else
3269 t = *tail = tline;
3270 tline = tline->next;
3271 t->mac = NULL;
3272 tail = &t->next;
3275 *tail = NULL;
3276 t = thead;
3277 for (; t && (tt = t->next) != NULL; t = t->next)
3278 switch (t->type)
3280 case TOK_WHITESPACE:
3281 if (tt->type == TOK_WHITESPACE)
3283 t->next = delete_Token(tt);
3285 break;
3286 case TOK_ID:
3287 if (tt->type == TOK_ID || tt->type == TOK_NUMBER)
3289 char *tmp = nasm_strcat(t->text, tt->text);
3290 nasm_free(t->text);
3291 t->text = tmp;
3292 t->next = delete_Token(tt);
3294 break;
3295 case TOK_NUMBER:
3296 if (tt->type == TOK_NUMBER)
3298 char *tmp = nasm_strcat(t->text, tt->text);
3299 nasm_free(t->text);
3300 t->text = tmp;
3301 t->next = delete_Token(tt);
3303 break;
3306 return thead;
3310 * Expand all single-line macro calls made in the given line.
3311 * Return the expanded version of the line. The original is deemed
3312 * to be destroyed in the process. (In reality we'll just move
3313 * Tokens from input to output a lot of the time, rather than
3314 * actually bothering to destroy and replicate.)
3316 static Token *
3317 expand_smacro(Token * tline)
3319 Token *t, *tt, *mstart, **tail, *thead;
3320 SMacro *head = NULL, *m;
3321 Token **params;
3322 int *paramsize;
3323 int nparam, sparam, brackets, rescan;
3324 Token *org_tline = tline;
3325 Context *ctx;
3326 char *mname;
3329 * Trick: we should avoid changing the start token pointer since it can
3330 * be contained in "next" field of other token. Because of this
3331 * we allocate a copy of first token and work with it; at the end of
3332 * routine we copy it back
3334 if (org_tline)
3336 tline =
3337 new_Token(org_tline->next, org_tline->type, org_tline->text,
3339 tline->mac = org_tline->mac;
3340 nasm_free(org_tline->text);
3341 org_tline->text = NULL;
3344 again:
3345 tail = &thead;
3346 thead = NULL;
3348 while (tline)
3349 { /* main token loop */
3350 if ((mname = tline->text))
3352 /* if this token is a local macro, look in local context */
3353 if (tline->type == TOK_ID || tline->type == TOK_PREPROC_ID)
3354 ctx = get_ctx(mname, TRUE);
3355 else
3356 ctx = NULL;
3357 if (!ctx)
3358 head = smacros[hash(mname)];
3359 else
3360 head = ctx->localmac;
3362 * We've hit an identifier. As in is_mmacro below, we first
3363 * check whether the identifier is a single-line macro at
3364 * all, then think about checking for parameters if
3365 * necessary.
3367 for (m = head; m; m = m->next)
3368 if (!mstrcmp(m->name, mname, m->casesense))
3369 break;
3370 if (m)
3372 mstart = tline;
3373 params = NULL;
3374 paramsize = NULL;
3375 if (m->nparam == 0)
3378 * Simple case: the macro is parameterless. Discard the
3379 * one token that the macro call took, and push the
3380 * expansion back on the to-do stack.
3382 if (!m->expansion)
3384 if (!strcmp("__FILE__", m->name))
3386 long num = 0;
3387 src_get(&num, &(tline->text));
3388 nasm_quote(&(tline->text));
3389 tline->type = TOK_STRING;
3390 continue;
3392 if (!strcmp("__LINE__", m->name))
3394 nasm_free(tline->text);
3395 make_tok_num(tline, src_get_linnum());
3396 continue;
3398 tline = delete_Token(tline);
3399 continue;
3402 else
3405 * Complicated case: at least one macro with this name
3406 * exists and takes parameters. We must find the
3407 * parameters in the call, count them, find the SMacro
3408 * that corresponds to that form of the macro call, and
3409 * substitute for the parameters when we expand. What a
3410 * pain.
3412 tline = tline->next;
3413 skip_white_(tline);
3414 if (!tok_is_(tline, "("))
3417 * This macro wasn't called with parameters: ignore
3418 * the call. (Behaviour borrowed from gnu cpp.)
3420 tline = mstart;
3421 m = NULL;
3423 else
3425 int paren = 0;
3426 int white = 0;
3427 brackets = 0;
3428 nparam = 0;
3429 tline = tline->next;
3430 sparam = PARAM_DELTA;
3431 params = nasm_malloc(sparam * sizeof(Token *));
3432 params[0] = tline;
3433 paramsize = nasm_malloc(sparam * sizeof(int));
3434 paramsize[0] = 0;
3435 for (;; tline = tline->next)
3436 { /* parameter loop */
3437 if (!tline)
3439 error(ERR_NONFATAL,
3440 "macro call expects terminating `)'");
3441 break;
3443 if (tline->type == TOK_WHITESPACE
3444 && brackets <= 0)
3446 if (paramsize[nparam])
3447 white++;
3448 else
3449 params[nparam] = tline->next;
3450 continue; /* parameter loop */
3452 if (tline->type == TOK_OTHER
3453 && tline->text[1] == 0)
3455 char ch = tline->text[0];
3456 if (ch == ',' && !paren && brackets <= 0)
3458 if (++nparam >= sparam)
3460 sparam += PARAM_DELTA;
3461 params = nasm_realloc(params,
3462 sparam * sizeof(Token *));
3463 paramsize = nasm_realloc(paramsize,
3464 sparam * sizeof(int));
3466 params[nparam] = tline->next;
3467 paramsize[nparam] = 0;
3468 white = 0;
3469 continue; /* parameter loop */
3471 if (ch == '{' &&
3472 (brackets > 0 || (brackets == 0 &&
3473 !paramsize[nparam])))
3475 if (!(brackets++))
3477 params[nparam] = tline->next;
3478 continue; /* parameter loop */
3481 if (ch == '}' && brackets > 0)
3482 if (--brackets == 0)
3484 brackets = -1;
3485 continue; /* parameter loop */
3487 if (ch == '(' && !brackets)
3488 paren++;
3489 if (ch == ')' && brackets <= 0)
3490 if (--paren < 0)
3491 break;
3493 if (brackets < 0)
3495 brackets = 0;
3496 error(ERR_NONFATAL, "braces do not "
3497 "enclose all of macro parameter");
3499 paramsize[nparam] += white + 1;
3500 white = 0;
3501 } /* parameter loop */
3502 nparam++;
3503 while (m && (m->nparam != nparam ||
3504 mstrcmp(m->name, mname,
3505 m->casesense)))
3506 m = m->next;
3507 if (!m)
3508 error(ERR_WARNING | ERR_WARN_MNP,
3509 "macro `%s' exists, "
3510 "but not taking %d parameters",
3511 mstart->text, nparam);
3514 if (m && m->in_progress)
3515 m = NULL;
3516 if (!m) /* in progess or didn't find '(' or wrong nparam */
3519 * Design question: should we handle !tline, which
3520 * indicates missing ')' here, or expand those
3521 * macros anyway, which requires the (t) test a few
3522 * lines down?
3524 nasm_free(params);
3525 nasm_free(paramsize);
3526 tline = mstart;
3528 else
3531 * Expand the macro: we are placed on the last token of the
3532 * call, so that we can easily split the call from the
3533 * following tokens. We also start by pushing an SMAC_END
3534 * token for the cycle removal.
3536 t = tline;
3537 if (t)
3539 tline = t->next;
3540 t->next = NULL;
3542 tt = new_Token(tline, TOK_SMAC_END, NULL, 0);
3543 tt->mac = m;
3544 m->in_progress = TRUE;
3545 tline = tt;
3546 for (t = m->expansion; t; t = t->next)
3548 if (t->type >= TOK_SMAC_PARAM)
3550 Token *pcopy = tline, **ptail = &pcopy;
3551 Token *ttt, *pt;
3552 int i;
3554 ttt = params[t->type - TOK_SMAC_PARAM];
3555 for (i = paramsize[t->type - TOK_SMAC_PARAM];
3556 --i >= 0;)
3558 pt = *ptail =
3559 new_Token(tline, ttt->type, ttt->text,
3561 ptail = &pt->next;
3562 ttt = ttt->next;
3564 tline = pcopy;
3566 else
3568 tt = new_Token(tline, t->type, t->text, 0);
3569 tline = tt;
3574 * Having done that, get rid of the macro call, and clean
3575 * up the parameters.
3577 nasm_free(params);
3578 nasm_free(paramsize);
3579 free_tlist(mstart);
3580 continue; /* main token loop */
3585 if (tline->type == TOK_SMAC_END)
3587 tline->mac->in_progress = FALSE;
3588 tline = delete_Token(tline);
3590 else
3592 t = *tail = tline;
3593 tline = tline->next;
3594 t->mac = NULL;
3595 t->next = NULL;
3596 tail = &t->next;
3601 * Now scan the entire line and look for successive TOK_IDs that resulted
3602 * after expansion (they can't be produced by tokenise()). The successive
3603 * TOK_IDs should be concatenated.
3604 * Also we look for %+ tokens and concatenate the tokens before and after
3605 * them (without white spaces in between).
3607 t = thead;
3608 rescan = 0;
3609 while (t)
3611 while (t && t->type != TOK_ID && t->type != TOK_PREPROC_ID)
3612 t = t->next;
3613 if (!t || !t->next)
3614 break;
3615 if (t->next->type == TOK_ID ||
3616 t->next->type == TOK_PREPROC_ID ||
3617 t->next->type == TOK_NUMBER)
3619 char *p = nasm_strcat(t->text, t->next->text);
3620 nasm_free(t->text);
3621 t->next = delete_Token(t->next);
3622 t->text = p;
3623 rescan = 1;
3625 else if (t->next->type == TOK_WHITESPACE && t->next->next &&
3626 t->next->next->type == TOK_PREPROC_ID &&
3627 strcmp(t->next->next->text, "%+") == 0)
3629 /* free the next whitespace, the %+ token and next whitespace */
3630 int i;
3631 for (i = 1; i <= 3; i++)
3633 if (!t->next || (i != 2 && t->next->type != TOK_WHITESPACE))
3634 break;
3635 t->next = delete_Token(t->next);
3636 } /* endfor */
3638 else
3639 t = t->next;
3641 /* If we concatenaded something, re-scan the line for macros */
3642 if (rescan)
3644 tline = thead;
3645 goto again;
3648 if (org_tline)
3650 if (thead)
3652 *org_tline = *thead;
3653 /* since we just gave text to org_line, don't free it */
3654 thead->text = NULL;
3655 delete_Token(thead);
3657 else
3659 /* the expression expanded to empty line;
3660 we can't return NULL for some reasons
3661 we just set the line to a single WHITESPACE token. */
3662 memset(org_tline, 0, sizeof(*org_tline));
3663 org_tline->text = NULL;
3664 org_tline->type = TOK_WHITESPACE;
3666 thead = org_tline;
3669 return thead;
3673 * Similar to expand_smacro but used exclusively with macro identifiers
3674 * right before they are fetched in. The reason is that there can be
3675 * identifiers consisting of several subparts. We consider that if there
3676 * are more than one element forming the name, user wants a expansion,
3677 * otherwise it will be left as-is. Example:
3679 * %define %$abc cde
3681 * the identifier %$abc will be left as-is so that the handler for %define
3682 * will suck it and define the corresponding value. Other case:
3684 * %define _%$abc cde
3686 * In this case user wants name to be expanded *before* %define starts
3687 * working, so we'll expand %$abc into something (if it has a value;
3688 * otherwise it will be left as-is) then concatenate all successive
3689 * PP_IDs into one.
3691 static Token *
3692 expand_id(Token * tline)
3694 Token *cur, *oldnext = NULL;
3696 if (!tline || !tline->next)
3697 return tline;
3699 cur = tline;
3700 while (cur->next &&
3701 (cur->next->type == TOK_ID ||
3702 cur->next->type == TOK_PREPROC_ID || cur->next->type == TOK_NUMBER))
3703 cur = cur->next;
3705 /* If identifier consists of just one token, don't expand */
3706 if (cur == tline)
3707 return tline;
3709 if (cur)
3711 oldnext = cur->next; /* Detach the tail past identifier */
3712 cur->next = NULL; /* so that expand_smacro stops here */
3715 tline = expand_smacro(tline);
3717 if (cur)
3719 /* expand_smacro possibly changhed tline; re-scan for EOL */
3720 cur = tline;
3721 while (cur && cur->next)
3722 cur = cur->next;
3723 if (cur)
3724 cur->next = oldnext;
3727 return tline;
3731 * Determine whether the given line constitutes a multi-line macro
3732 * call, and return the MMacro structure called if so. Doesn't have
3733 * to check for an initial label - that's taken care of in
3734 * expand_mmacro - but must check numbers of parameters. Guaranteed
3735 * to be called with tline->type == TOK_ID, so the putative macro
3736 * name is easy to find.
3738 static MMacro *
3739 is_mmacro(Token * tline, Token *** params_array)
3741 MMacro *head, *m;
3742 Token **params;
3743 int nparam;
3745 head = mmacros[hash(tline->text)];
3748 * Efficiency: first we see if any macro exists with the given
3749 * name. If not, we can return NULL immediately. _Then_ we
3750 * count the parameters, and then we look further along the
3751 * list if necessary to find the proper MMacro.
3753 for (m = head; m; m = m->next)
3754 if (!mstrcmp(m->name, tline->text, m->casesense))
3755 break;
3756 if (!m)
3757 return NULL;
3760 * OK, we have a potential macro. Count and demarcate the
3761 * parameters.
3763 count_mmac_params(tline->next, &nparam, &params);
3766 * So we know how many parameters we've got. Find the MMacro
3767 * structure that handles this number.
3769 while (m)
3771 if (m->nparam_min <= nparam && (m->plus || nparam <= m->nparam_max))
3774 * This one is right. Just check if cycle removal
3775 * prohibits us using it before we actually celebrate...
3777 if (m->in_progress)
3779 #if 0
3780 error(ERR_NONFATAL,
3781 "self-reference in multi-line macro `%s'", m->name);
3782 #endif
3783 nasm_free(params);
3784 return NULL;
3787 * It's right, and we can use it. Add its default
3788 * parameters to the end of our list if necessary.
3790 if (m->defaults && nparam < m->nparam_min + m->ndefs)
3792 params =
3793 nasm_realloc(params,
3794 ((m->nparam_min + m->ndefs + 1) * sizeof(*params)));
3795 while (nparam < m->nparam_min + m->ndefs)
3797 params[nparam] = m->defaults[nparam - m->nparam_min];
3798 nparam++;
3802 * If we've gone over the maximum parameter count (and
3803 * we're in Plus mode), ignore parameters beyond
3804 * nparam_max.
3806 if (m->plus && nparam > m->nparam_max)
3807 nparam = m->nparam_max;
3809 * Then terminate the parameter list, and leave.
3811 if (!params)
3812 { /* need this special case */
3813 params = nasm_malloc(sizeof(*params));
3814 nparam = 0;
3816 params[nparam] = NULL;
3817 *params_array = params;
3818 return m;
3821 * This one wasn't right: look for the next one with the
3822 * same name.
3824 for (m = m->next; m; m = m->next)
3825 if (!mstrcmp(m->name, tline->text, m->casesense))
3826 break;
3830 * After all that, we didn't find one with the right number of
3831 * parameters. Issue a warning, and fail to expand the macro.
3833 error(ERR_WARNING | ERR_WARN_MNP,
3834 "macro `%s' exists, but not taking %d parameters",
3835 tline->text, nparam);
3836 nasm_free(params);
3837 return NULL;
3841 * Expand the multi-line macro call made by the given line, if
3842 * there is one to be expanded. If there is, push the expansion on
3843 * istk->expansion and return 1. Otherwise return 0.
3845 static int
3846 expand_mmacro(Token * tline)
3848 Token *startline = tline;
3849 Token *label = NULL;
3850 int dont_prepend = 0;
3851 Token **params, *t, *tt;
3852 MMacro *m;
3853 Line *l, *ll;
3854 int i, nparam, *paramlen;
3856 t = tline;
3857 skip_white_(t);
3858 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
3859 if (!tok_type_(t, TOK_ID) && !tok_type_(t, TOK_PREPROC_ID))
3860 return 0;
3861 m = is_mmacro(t, &params);
3862 if (!m)
3864 Token *last;
3866 * We have an id which isn't a macro call. We'll assume
3867 * it might be a label; we'll also check to see if a
3868 * colon follows it. Then, if there's another id after
3869 * that lot, we'll check it again for macro-hood.
3871 label = last = t;
3872 t = t->next;
3873 if (tok_type_(t, TOK_WHITESPACE))
3874 last = t, t = t->next;
3875 if (tok_is_(t, ":"))
3877 dont_prepend = 1;
3878 last = t, t = t->next;
3879 if (tok_type_(t, TOK_WHITESPACE))
3880 last = t, t = t->next;
3882 if (!tok_type_(t, TOK_ID) || (m = is_mmacro(t, &params)) == NULL)
3883 return 0;
3884 last->next = NULL;
3885 tline = t;
3889 * Fix up the parameters: this involves stripping leading and
3890 * trailing whitespace, then stripping braces if they are
3891 * present.
3893 for (nparam = 0; params[nparam]; nparam++)
3895 paramlen = nparam ? nasm_malloc(nparam * sizeof(*paramlen)) : NULL;
3897 for (i = 0; params[i]; i++)
3899 int brace = FALSE;
3900 int comma = (!m->plus || i < nparam - 1);
3902 t = params[i];
3903 skip_white_(t);
3904 if (tok_is_(t, "{"))
3905 t = t->next, brace = TRUE, comma = FALSE;
3906 params[i] = t;
3907 paramlen[i] = 0;
3908 while (t)
3910 if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
3911 break; /* ... because we have hit a comma */
3912 if (comma && t->type == TOK_WHITESPACE && tok_is_(t->next, ","))
3913 break; /* ... or a space then a comma */
3914 if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
3915 break; /* ... or a brace */
3916 t = t->next;
3917 paramlen[i]++;
3922 * OK, we have a MMacro structure together with a set of
3923 * parameters. We must now go through the expansion and push
3924 * copies of each Line on to istk->expansion. Substitution of
3925 * parameter tokens and macro-local tokens doesn't get done
3926 * until the single-line macro substitution process; this is
3927 * because delaying them allows us to change the semantics
3928 * later through %rotate.
3930 * First, push an end marker on to istk->expansion, mark this
3931 * macro as in progress, and set up its invocation-specific
3932 * variables.
3934 ll = nasm_malloc(sizeof(Line));
3935 ll->next = istk->expansion;
3936 ll->finishes = m;
3937 ll->first = NULL;
3938 istk->expansion = ll;
3940 m->in_progress = TRUE;
3941 m->params = params;
3942 m->iline = tline;
3943 m->nparam = nparam;
3944 m->rotate = 0;
3945 m->paramlen = paramlen;
3946 m->unique = unique++;
3947 m->lineno = 0;
3949 m->next_active = istk->mstk;
3950 istk->mstk = m;
3952 for (l = m->expansion; l; l = l->next)
3954 Token **tail;
3956 ll = nasm_malloc(sizeof(Line));
3957 ll->finishes = NULL;
3958 ll->next = istk->expansion;
3959 istk->expansion = ll;
3960 tail = &ll->first;
3962 for (t = l->first; t; t = t->next)
3964 Token *x = t;
3965 if (t->type == TOK_PREPROC_ID &&
3966 t->text[1] == '0' && t->text[2] == '0')
3968 dont_prepend = -1;
3969 x = label;
3970 if (!x)
3971 continue;
3973 tt = *tail = new_Token(NULL, x->type, x->text, 0);
3974 tail = &tt->next;
3976 *tail = NULL;
3980 * If we had a label, push it on as the first line of
3981 * the macro expansion.
3983 if (label)
3985 if (dont_prepend < 0)
3986 free_tlist(startline);
3987 else
3989 ll = nasm_malloc(sizeof(Line));
3990 ll->finishes = NULL;
3991 ll->next = istk->expansion;
3992 istk->expansion = ll;
3993 ll->first = startline;
3994 if (!dont_prepend)
3996 while (label->next)
3997 label = label->next;
3998 label->next = tt = new_Token(NULL, TOK_OTHER, ":", 0);
4003 list->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
4005 return 1;
4009 * Since preprocessor always operate only on the line that didn't
4010 * arrived yet, we should always use ERR_OFFBY1. Also since user
4011 * won't want to see same error twice (preprocessing is done once
4012 * per pass) we will want to show errors only during pass one.
4014 static void
4015 error(int severity, const char *fmt, ...)
4017 va_list arg;
4018 char buff[1024];
4020 /* If we're in a dead branch of IF or something like it, ignore the error */
4021 if (istk && istk->conds && !emitting(istk->conds->state))
4022 return;
4024 va_start(arg, fmt);
4025 vsprintf(buff, fmt, arg);
4026 va_end(arg);
4028 if (istk && istk->mstk && istk->mstk->name)
4029 _error(severity | ERR_PASS1, "(%s:%d) %s", istk->mstk->name,
4030 istk->mstk->lineno, buff);
4031 else
4032 _error(severity | ERR_PASS1, "%s", buff);
4035 static void
4036 pp_reset(char *file, int apass, efunc errfunc, evalfunc eval,
4037 ListGen * listgen)
4039 int h;
4041 _error = errfunc;
4042 cstk = NULL;
4043 istk = nasm_malloc(sizeof(Include));
4044 istk->next = NULL;
4045 istk->conds = NULL;
4046 istk->expansion = NULL;
4047 istk->mstk = NULL;
4048 istk->fp = fopen(file, "r");
4049 istk->fname = NULL;
4050 src_set_fname(nasm_strdup(file));
4051 src_set_linnum(0);
4052 istk->lineinc = 1;
4053 if (!istk->fp)
4054 error(ERR_FATAL | ERR_NOFILE, "unable to open input file `%s'", file);
4055 defining = NULL;
4056 for (h = 0; h < NHASH; h++)
4058 mmacros[h] = NULL;
4059 smacros[h] = NULL;
4061 unique = 0;
4062 if (tasm_compatible_mode) {
4063 stdmacpos = stdmac;
4064 } else {
4065 stdmacpos = &stdmac[TASM_MACRO_COUNT];
4067 any_extrastdmac = (extrastdmac != NULL);
4068 list = listgen;
4069 evaluate = eval;
4070 pass = apass;
4073 static char *
4074 pp_getline(void)
4076 char *line;
4077 Token *tline;
4079 while (1)
4082 * Fetch a tokenised line, either from the macro-expansion
4083 * buffer or from the input file.
4085 tline = NULL;
4086 while (istk->expansion && istk->expansion->finishes)
4088 Line *l = istk->expansion;
4089 if (!l->finishes->name && l->finishes->in_progress > 1)
4091 Line *ll;
4094 * This is a macro-end marker for a macro with no
4095 * name, which means it's not really a macro at all
4096 * but a %rep block, and the `in_progress' field is
4097 * more than 1, meaning that we still need to
4098 * repeat. (1 means the natural last repetition; 0
4099 * means termination by %exitrep.) We have
4100 * therefore expanded up to the %endrep, and must
4101 * push the whole block on to the expansion buffer
4102 * again. We don't bother to remove the macro-end
4103 * marker: we'd only have to generate another one
4104 * if we did.
4106 l->finishes->in_progress--;
4107 for (l = l->finishes->expansion; l; l = l->next)
4109 Token *t, *tt, **tail;
4111 ll = nasm_malloc(sizeof(Line));
4112 ll->next = istk->expansion;
4113 ll->finishes = NULL;
4114 ll->first = NULL;
4115 tail = &ll->first;
4117 for (t = l->first; t; t = t->next)
4119 if (t->text || t->type == TOK_WHITESPACE)
4121 tt = *tail = new_Token(NULL, t->type, t->text, 0);
4122 tail = &tt->next;
4126 istk->expansion = ll;
4129 else
4132 * Check whether a `%rep' was started and not ended
4133 * within this macro expansion. This can happen and
4134 * should be detected. It's a fatal error because
4135 * I'm too confused to work out how to recover
4136 * sensibly from it.
4138 if (defining)
4140 if (defining->name)
4141 error(ERR_PANIC, "defining with name in expansion");
4142 else if (istk->mstk->name)
4143 error(ERR_FATAL, "`%%rep' without `%%endrep' within"
4144 " expansion of macro `%s'", istk->mstk->name);
4148 * FIXME: investigate the relationship at this point between
4149 * istk->mstk and l->finishes
4152 MMacro *m = istk->mstk;
4153 istk->mstk = m->next_active;
4154 if (m->name)
4157 * This was a real macro call, not a %rep, and
4158 * therefore the parameter information needs to
4159 * be freed.
4161 nasm_free(m->params);
4162 free_tlist(m->iline);
4163 nasm_free(m->paramlen);
4164 l->finishes->in_progress = FALSE;
4166 else
4167 free_mmacro(m);
4169 istk->expansion = l->next;
4170 nasm_free(l);
4171 list->downlevel(LIST_MACRO);
4174 while (1)
4175 { /* until we get a line we can use */
4177 if (istk->expansion)
4178 { /* from a macro expansion */
4179 char *p;
4180 Line *l = istk->expansion;
4181 if (istk->mstk)
4182 istk->mstk->lineno++;
4183 tline = l->first;
4184 istk->expansion = l->next;
4185 nasm_free(l);
4186 p = detoken(tline, FALSE);
4187 list->line(LIST_MACRO, p);
4188 nasm_free(p);
4189 break;
4191 line = read_line();
4192 if (line)
4193 { /* from the current input file */
4194 line = prepreproc(line);
4195 tline = tokenise(line);
4196 nasm_free(line);
4197 break;
4200 * The current file has ended; work down the istk
4203 Include *i = istk;
4204 fclose(i->fp);
4205 if (i->conds)
4206 error(ERR_FATAL, "expected `%%endif' before end of file");
4207 /* only set line and file name if there's a next node */
4208 if (i->next)
4210 src_set_linnum(i->lineno);
4211 nasm_free(src_set_fname(i->fname));
4213 istk = i->next;
4214 list->downlevel(LIST_INCLUDE);
4215 nasm_free(i);
4216 if (!istk)
4217 return NULL;
4222 * We must expand MMacro parameters and MMacro-local labels
4223 * _before_ we plunge into directive processing, to cope
4224 * with things like `%define something %1' such as STRUC
4225 * uses. Unless we're _defining_ a MMacro, in which case
4226 * those tokens should be left alone to go into the
4227 * definition; and unless we're in a non-emitting
4228 * condition, in which case we don't want to meddle with
4229 * anything.
4231 if (!defining && !(istk->conds && !emitting(istk->conds->state)))
4232 tline = expand_mmac_params(tline);
4235 * Check the line to see if it's a preprocessor directive.
4237 if (do_directive(tline) & 1)
4239 continue;
4241 else if (defining)
4244 * We're defining a multi-line macro. We emit nothing
4245 * at all, and just
4246 * shove the tokenised line on to the macro definition.
4248 Line *l = nasm_malloc(sizeof(Line));
4249 l->next = defining->expansion;
4250 l->first = tline;
4251 l->finishes = FALSE;
4252 defining->expansion = l;
4253 continue;
4255 else if (istk->conds && !emitting(istk->conds->state))
4258 * We're in a non-emitting branch of a condition block.
4259 * Emit nothing at all, not even a blank line: when we
4260 * emerge from the condition we'll give a line-number
4261 * directive so we keep our place correctly.
4263 free_tlist(tline);
4264 continue;
4266 else if (istk->mstk && !istk->mstk->in_progress)
4269 * We're in a %rep block which has been terminated, so
4270 * we're walking through to the %endrep without
4271 * emitting anything. Emit nothing at all, not even a
4272 * blank line: when we emerge from the %rep block we'll
4273 * give a line-number directive so we keep our place
4274 * correctly.
4276 free_tlist(tline);
4277 continue;
4279 else
4281 tline = expand_smacro(tline);
4282 if (!expand_mmacro(tline))
4285 * De-tokenise the line again, and emit it.
4287 line = detoken(tline, TRUE);
4288 free_tlist(tline);
4289 break;
4291 else
4293 continue; /* expand_mmacro calls free_tlist */
4298 return line;
4301 static void
4302 pp_cleanup(int pass)
4304 int h;
4306 if (defining)
4308 error(ERR_NONFATAL, "end of file while still defining macro `%s'",
4309 defining->name);
4310 free_mmacro(defining);
4312 while (cstk)
4313 ctx_pop();
4314 for (h = 0; h < NHASH; h++)
4316 while (mmacros[h])
4318 MMacro *m = mmacros[h];
4319 mmacros[h] = mmacros[h]->next;
4320 free_mmacro(m);
4322 while (smacros[h])
4324 SMacro *s = smacros[h];
4325 smacros[h] = smacros[h]->next;
4326 nasm_free(s->name);
4327 free_tlist(s->expansion);
4328 nasm_free(s);
4331 while (istk)
4333 Include *i = istk;
4334 istk = istk->next;
4335 fclose(i->fp);
4336 nasm_free(i->fname);
4337 nasm_free(i);
4339 while (cstk)
4340 ctx_pop();
4341 if (pass == 0)
4343 free_llist(predef);
4344 delete_Blocks();
4348 void
4349 pp_include_path(char *path)
4351 IncPath *i;
4353 i = nasm_malloc(sizeof(IncPath));
4354 i->path = nasm_strdup(path);
4355 i->next = ipath;
4356 ipath = i;
4359 void
4360 pp_pre_include(char *fname)
4362 Token *inc, *space, *name;
4363 Line *l;
4365 name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
4366 space = new_Token(name, TOK_WHITESPACE, NULL, 0);
4367 inc = new_Token(space, TOK_PREPROC_ID, "%include", 0);
4369 l = nasm_malloc(sizeof(Line));
4370 l->next = predef;
4371 l->first = inc;
4372 l->finishes = FALSE;
4373 predef = l;
4376 void
4377 pp_pre_define(char *definition)
4379 Token *def, *space;
4380 Line *l;
4381 char *equals;
4383 equals = strchr(definition, '=');
4384 space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4385 def = new_Token(space, TOK_PREPROC_ID, "%define", 0);
4386 if (equals)
4387 *equals = ' ';
4388 space->next = tokenise(definition);
4389 if (equals)
4390 *equals = '=';
4392 l = nasm_malloc(sizeof(Line));
4393 l->next = predef;
4394 l->first = def;
4395 l->finishes = FALSE;
4396 predef = l;
4399 void
4400 pp_pre_undefine(char *definition)
4402 Token *def, *space;
4403 Line *l;
4405 space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4406 def = new_Token(space, TOK_PREPROC_ID, "%undef", 0);
4408 l = nasm_malloc(sizeof(Line));
4409 l->next = predef;
4410 l->first = def;
4411 l->finishes = FALSE;
4412 predef = l;
4415 void
4416 pp_extra_stdmac(char **macros)
4418 extrastdmac = macros;
4421 static void
4422 make_tok_num(Token * tok, long val)
4424 char numbuf[20];
4425 sprintf(numbuf, "%ld", val);
4426 tok->text = nasm_strdup(numbuf);
4427 tok->type = TOK_NUMBER;
4430 Preproc nasmpp = {
4431 pp_reset,
4432 pp_getline,
4433 pp_cleanup