Touch up Makefile.b32
[nasm/autotest.git] / preproc.c
blob8974945323a082d0514d11a1eb27421f91f3057a
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 * These defines are used as the possible return values for do_directive
254 #define NO_DIRECTIVE_FOUND 0
255 #define DIRECTIVE_FOUND 1
258 * Condition codes. Note that we use c_ prefix not C_ because C_ is
259 * used in nasm.h for the "real" condition codes. At _this_ level,
260 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
261 * ones, so we need a different enum...
263 static const char *conditions[] = {
264 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
265 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
266 "np", "ns", "nz", "o", "p", "pe", "po", "s", "z"
268 enum
270 c_A, c_AE, c_B, c_BE, c_C, c_CXZ, c_E, c_ECXZ, c_G, c_GE, c_L, c_LE,
271 c_NA, c_NAE, c_NB, c_NBE, c_NC, c_NE, c_NG, c_NGE, c_NL, c_NLE, c_NO,
272 c_NP, c_NS, c_NZ, c_O, c_P, c_PE, c_PO, c_S, c_Z
274 static int inverse_ccs[] = {
275 c_NA, c_NAE, c_NB, c_NBE, c_NC, -1, c_NE, -1, c_NG, c_NGE, c_NL, c_NLE,
276 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,
277 c_Z, c_NO, c_NP, c_PO, c_PE, c_NS, c_NZ
281 * Directive names.
283 static const char *directives[] = {
284 "%arg",
285 "%assign", "%clear", "%define", "%elif", "%elifctx", "%elifdef",
286 "%elifid", "%elifidn", "%elifidni", "%elifmacro", "%elifnctx", "%elifndef",
287 "%elifnid", "%elifnidn", "%elifnidni", "%elifnmacro", "%elifnnum", "%elifnstr",
288 "%elifnum", "%elifstr", "%else", "%endif", "%endm", "%endmacro",
289 "%endrep", "%error", "%exitrep", "%iassign", "%idefine", "%if",
290 "%ifctx", "%ifdef", "%ifid", "%ifidn", "%ifidni", "%ifmacro", "%ifnctx",
291 "%ifndef", "%ifnid", "%ifnidn", "%ifnidni", "%ifnmacro", "%ifnnum",
292 "%ifnstr", "%ifnum", "%ifstr", "%imacro", "%include",
293 "%ixdefine", "%line",
294 "%local",
295 "%macro", "%pop", "%push", "%rep", "%repl", "%rotate",
296 "%stacksize",
297 "%strlen", "%substr", "%undef", "%xdefine"
299 enum
301 PP_ARG,
302 PP_ASSIGN, PP_CLEAR, PP_DEFINE, PP_ELIF, PP_ELIFCTX, PP_ELIFDEF,
303 PP_ELIFID, PP_ELIFIDN, PP_ELIFIDNI, PP_ELIFMACRO, PP_ELIFNCTX, PP_ELIFNDEF,
304 PP_ELIFNID, PP_ELIFNIDN, PP_ELIFNIDNI, PP_ELIFNMACRO, PP_ELIFNNUM, PP_ELIFNSTR,
305 PP_ELIFNUM, PP_ELIFSTR, PP_ELSE, PP_ENDIF, PP_ENDM, PP_ENDMACRO,
306 PP_ENDREP, PP_ERROR, PP_EXITREP, PP_IASSIGN, PP_IDEFINE, PP_IF,
307 PP_IFCTX, PP_IFDEF, PP_IFID, PP_IFIDN, PP_IFIDNI, PP_IFMACRO, PP_IFNCTX,
308 PP_IFNDEF, PP_IFNID, PP_IFNIDN, PP_IFNIDNI, PP_IFNMACRO, PP_IFNNUM,
309 PP_IFNSTR, PP_IFNUM, PP_IFSTR, PP_IMACRO, PP_INCLUDE,
310 PP_IXDEFINE, PP_LINE,
311 PP_LOCAL,
312 PP_MACRO, PP_POP, PP_PUSH, PP_REP, PP_REPL, PP_ROTATE,
313 PP_STACKSIZE,
314 PP_STRLEN, PP_SUBSTR, PP_UNDEF, PP_XDEFINE
317 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
318 static int is_condition(int arg)
320 return ((arg >= PP_ELIF) && (arg <= PP_ENDIF)) ||
321 ((arg >= PP_IF) && (arg <= PP_IFSTR));
324 /* For TASM compatibility we need to be able to recognise TASM compatible
325 * conditional compilation directives. Using the NASM pre-processor does
326 * not work, so we look for them specifically from the following list and
327 * then jam in the equivalent NASM directive into the input stream.
330 #ifndef MAX
331 # define MAX(a,b) ( ((a) > (b)) ? (a) : (b))
332 #endif
334 enum
336 TM_ARG, TM_ELIF, TM_ELSE, TM_ENDIF, TM_IF, TM_IFDEF, TM_IFDIFI,
337 TM_IFNDEF, TM_INCLUDE, TM_LOCAL
340 static const char *tasm_directives[] = {
341 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
342 "ifndef", "include", "local"
345 static int StackSize = 4;
346 static char *StackPointer = "ebp";
347 static int ArgOffset = 8;
348 static int LocalOffset = 4;
351 static Context *cstk;
352 static Include *istk;
353 static IncPath *ipath = NULL;
355 static efunc _error; /* Pointer to client-provided error reporting function */
356 static evalfunc evaluate;
358 static int pass; /* HACK: pass 0 = generate dependencies only */
360 static unsigned long unique; /* unique identifier numbers */
362 static Line *predef = NULL;
364 static ListGen *list;
367 * The number of hash values we use for the macro lookup tables.
368 * FIXME: We should *really* be able to configure this at run time,
369 * or even have the hash table automatically expanding when necessary.
371 #define NHASH 31
374 * The current set of multi-line macros we have defined.
376 static MMacro *mmacros[NHASH];
379 * The current set of single-line macros we have defined.
381 static SMacro *smacros[NHASH];
384 * The multi-line macro we are currently defining, or the %rep
385 * block we are currently reading, if any.
387 static MMacro *defining;
390 * The number of macro parameters to allocate space for at a time.
392 #define PARAM_DELTA 16
395 * The standard macro set: defined as `static char *stdmac[]'. Also
396 * gives our position in the macro set, when we're processing it.
398 #include "macros.c"
399 static const char **stdmacpos;
402 * The extra standard macros that come from the object format, if
403 * any.
405 static const char **extrastdmac = NULL;
406 int any_extrastdmac;
409 * Tokens are allocated in blocks to improve speed
411 #define TOKEN_BLOCKSIZE 4096
412 static Token *freeTokens = NULL;
413 struct Blocks {
414 Blocks *next;
415 void *chunk;
418 static Blocks blocks = { NULL, NULL };
421 * Forward declarations.
423 static Token *expand_mmac_params(Token * tline);
424 static Token *expand_smacro(Token * tline);
425 static Token *expand_id(Token * tline);
426 static Context *get_ctx(char *name, int all_contexts);
427 static void make_tok_num(Token * tok, long val);
428 static void error(int severity, const char *fmt, ...);
429 static void *new_Block(size_t size);
430 static void delete_Blocks(void);
431 static Token *new_Token(Token * next, int type, char *text, int txtlen);
432 static Token *delete_Token(Token * t);
435 * Macros for safe checking of token pointers, avoid *(NULL)
437 #define tok_type_(x,t) ((x) && (x)->type == (t))
438 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
439 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
440 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
442 /* Handle TASM specific directives, which do not contain a % in
443 * front of them. We do it here because I could not find any other
444 * place to do it for the moment, and it is a hack (ideally it would
445 * be nice to be able to use the NASM pre-processor to do it).
447 static char *
448 check_tasm_directive(char *line)
450 int i, j, k, m, len;
451 char *p = line, *oldline, oldchar;
453 /* Skip whitespace */
454 while (isspace(*p) && *p != 0)
455 p++;
457 /* Binary search for the directive name */
458 i = -1;
459 j = elements(tasm_directives);
460 len = 0;
461 while (!isspace(p[len]) && p[len] != 0)
462 len++;
463 if (len)
465 oldchar = p[len];
466 p[len] = 0;
467 while (j - i > 1)
469 k = (j + i) / 2;
470 m = nasm_stricmp(p, tasm_directives[k]);
471 if (m == 0)
473 /* We have found a directive, so jam a % in front of it
474 * so that NASM will then recognise it as one if it's own.
476 p[len] = oldchar;
477 len = strlen(p);
478 oldline = line;
479 line = nasm_malloc(len + 2);
480 line[0] = '%';
481 if (k == TM_IFDIFI)
483 /* NASM does not recognise IFDIFI, so we convert it to
484 * %ifdef BOGUS. This is not used in NASM comaptible
485 * code, but does need to parse for the TASM macro
486 * package.
488 strcpy(line + 1, "ifdef BOGUS");
490 else
492 memcpy(line + 1, p, len + 1);
494 nasm_free(oldline);
495 return line;
497 else if (m < 0)
499 j = k;
501 else
502 i = k;
504 p[len] = oldchar;
506 return line;
510 * The pre-preprocessing stage... This function translates line
511 * number indications as they emerge from GNU cpp (`# lineno "file"
512 * flags') into NASM preprocessor line number indications (`%line
513 * lineno file').
515 static char *
516 prepreproc(char *line)
518 int lineno, fnlen;
519 char *fname, *oldline;
521 if (line[0] == '#' && line[1] == ' ')
523 oldline = line;
524 fname = oldline + 2;
525 lineno = atoi(fname);
526 fname += strspn(fname, "0123456789 ");
527 if (*fname == '"')
528 fname++;
529 fnlen = strcspn(fname, "\"");
530 line = nasm_malloc(20 + fnlen);
531 sprintf(line, "%%line %d %.*s", lineno, fnlen, fname);
532 nasm_free(oldline);
534 if (tasm_compatible_mode)
535 return check_tasm_directive(line);
536 return line;
540 * The hash function for macro lookups. Note that due to some
541 * macros having case-insensitive names, the hash function must be
542 * invariant under case changes. We implement this by applying a
543 * perfectly normal hash function to the uppercase of the string.
545 static int
546 hash(char *s)
548 unsigned int h = 0;
549 int i = 0;
551 * Powers of three, mod 31.
553 static const int multipliers[] = {
554 1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10,
555 30, 28, 22, 4, 12, 5, 15, 14, 11, 2, 6, 18, 23, 7, 21
559 while (*s)
561 h += multipliers[i] * (unsigned char) (toupper(*s));
562 s++;
563 if (++i >= elements(multipliers))
564 i = 0;
566 h %= NHASH;
567 return h;
571 * Free a linked list of tokens.
573 static void
574 free_tlist(Token * list)
576 while (list)
578 list = delete_Token(list);
583 * Free a linked list of lines.
585 static void
586 free_llist(Line * list)
588 Line *l;
589 while (list)
591 l = list;
592 list = list->next;
593 free_tlist(l->first);
594 nasm_free(l);
599 * Free an MMacro
601 static void
602 free_mmacro(MMacro * m)
604 nasm_free(m->name);
605 free_tlist(m->dlist);
606 nasm_free(m->defaults);
607 free_llist(m->expansion);
608 nasm_free(m);
612 * Pop the context stack.
614 static void
615 ctx_pop(void)
617 Context *c = cstk;
618 SMacro *smac, *s;
620 cstk = cstk->next;
621 smac = c->localmac;
622 while (smac)
624 s = smac;
625 smac = smac->next;
626 nasm_free(s->name);
627 free_tlist(s->expansion);
628 nasm_free(s);
630 nasm_free(c->name);
631 nasm_free(c);
634 #define BUF_DELTA 512
636 * Read a line from the top file in istk, handling multiple CR/LFs
637 * at the end of the line read, and handling spurious ^Zs. Will
638 * return lines from the standard macro set if this has not already
639 * been done.
641 static char *
642 read_line(void)
644 char *buffer, *p, *q;
645 int bufsize, continued_count;
647 if (stdmacpos)
649 if (*stdmacpos)
651 char *ret = nasm_strdup(*stdmacpos++);
652 if (!*stdmacpos && any_extrastdmac)
654 stdmacpos = extrastdmac;
655 any_extrastdmac = FALSE;
656 return ret;
659 * Nasty hack: here we push the contents of `predef' on
660 * to the top-level expansion stack, since this is the
661 * most convenient way to implement the pre-include and
662 * pre-define features.
664 if (!*stdmacpos)
666 Line *pd, *l;
667 Token *head, **tail, *t;
669 for (pd = predef; pd; pd = pd->next)
671 head = NULL;
672 tail = &head;
673 for (t = pd->first; t; t = t->next)
675 *tail = new_Token(NULL, t->type, t->text, 0);
676 tail = &(*tail)->next;
678 l = nasm_malloc(sizeof(Line));
679 l->next = istk->expansion;
680 l->first = head;
681 l->finishes = FALSE;
682 istk->expansion = l;
685 return ret;
687 else
689 stdmacpos = NULL;
693 bufsize = BUF_DELTA;
694 buffer = nasm_malloc(BUF_DELTA);
695 p = buffer;
696 continued_count = 0;
697 while (1)
699 q = fgets(p, bufsize - (p - buffer), istk->fp);
700 if (!q)
701 break;
702 p += strlen(p);
703 if (p > buffer && p[-1] == '\n')
705 /* Convert backslash-CRLF line continuation sequences into
706 nothing at all (for DOS and Windows) */
707 if (((p - 2) > buffer) && (p[-3] == '\\') && (p[-2] == '\r')) {
708 p -= 3;
709 *p = 0;
710 continued_count++;
712 /* Also convert backslash-LF line continuation sequences into
713 nothing at all (for Unix) */
714 else if (((p - 1) > buffer) && (p[-2] == '\\')) {
715 p -= 2;
716 *p = 0;
717 continued_count++;
719 else {
720 break;
723 if (p - buffer > bufsize - 10)
725 long offset = p - buffer;
726 bufsize += BUF_DELTA;
727 buffer = nasm_realloc(buffer, bufsize);
728 p = buffer + offset; /* prevent stale-pointer problems */
732 if (!q && p == buffer)
734 nasm_free(buffer);
735 return NULL;
738 src_set_linnum(src_get_linnum() + istk->lineinc + (continued_count * istk->lineinc));
741 * Play safe: remove CRs as well as LFs, if any of either are
742 * present at the end of the line.
744 while (--p >= buffer && (*p == '\n' || *p == '\r'))
745 *p = '\0';
748 * Handle spurious ^Z, which may be inserted into source files
749 * by some file transfer utilities.
751 buffer[strcspn(buffer, "\032")] = '\0';
753 list->line(LIST_READ, buffer);
755 return buffer;
759 * Tokenise a line of text. This is a very simple process since we
760 * don't need to parse the value out of e.g. numeric tokens: we
761 * simply split one string into many.
763 static Token *
764 tokenise(char *line)
766 char *p = line;
767 int type;
768 Token *list = NULL;
769 Token *t, **tail = &list;
771 while (*line)
773 p = line;
774 if (*p == '%')
776 p++;
777 if ( isdigit(*p) ||
778 ((*p == '-' || *p == '+') && isdigit(p[1])) ||
779 ((*p == '+') && (isspace(p[1]) || !p[1])))
783 p++;
785 while (isdigit(*p));
786 type = TOK_PREPROC_ID;
788 else if (*p == '{')
790 p++;
791 while (*p && *p != '}')
793 p[-1] = *p;
794 p++;
796 p[-1] = '\0';
797 if (*p)
798 p++;
799 type = TOK_PREPROC_ID;
801 else if (isidchar(*p) ||
802 ((*p == '!' || *p == '%' || *p == '$') &&
803 isidchar(p[1])))
807 p++;
809 while (isidchar(*p));
810 type = TOK_PREPROC_ID;
812 else
814 type = TOK_OTHER;
815 if (*p == '%')
816 p++;
819 else if (isidstart(*p) || (*p == '$' && isidstart(p[1])))
821 type = TOK_ID;
822 p++;
823 while (*p && isidchar(*p))
824 p++;
826 else if (*p == '\'' || *p == '"')
829 * A string token.
831 char c = *p;
832 p++;
833 type = TOK_STRING;
834 while (*p && *p != c)
835 p++;
836 if (*p)
838 p++;
840 else
842 error(ERR_WARNING, "unterminated string");
845 else if (isnumstart(*p))
848 * A number token.
850 type = TOK_NUMBER;
851 p++;
852 while (*p && isnumchar(*p))
853 p++;
855 else if (isspace(*p))
857 type = TOK_WHITESPACE;
858 p++;
859 while (*p && isspace(*p))
860 p++;
862 * Whitespace just before end-of-line is discarded by
863 * pretending it's a comment; whitespace just before a
864 * comment gets lumped into the comment.
866 if (!*p || *p == ';')
868 type = TOK_COMMENT;
869 while (*p)
870 p++;
873 else if (*p == ';')
875 type = TOK_COMMENT;
876 while (*p)
877 p++;
879 else
882 * Anything else is an operator of some kind. We check
883 * for all the double-character operators (>>, <<, //,
884 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
885 * else is a single-character operator.
887 type = TOK_OTHER;
888 if ((p[0] == '>' && p[1] == '>') ||
889 (p[0] == '<' && p[1] == '<') ||
890 (p[0] == '/' && p[1] == '/') ||
891 (p[0] == '<' && p[1] == '=') ||
892 (p[0] == '>' && p[1] == '=') ||
893 (p[0] == '=' && p[1] == '=') ||
894 (p[0] == '!' && p[1] == '=') ||
895 (p[0] == '<' && p[1] == '>') ||
896 (p[0] == '&' && p[1] == '&') ||
897 (p[0] == '|' && p[1] == '|') ||
898 (p[0] == '^' && p[1] == '^'))
900 p++;
902 p++;
904 if (type != TOK_COMMENT)
906 *tail = t = new_Token(NULL, type, line, p - line);
907 tail = &t->next;
909 line = p;
911 return list;
915 * this function allocates a new managed block of memory and
916 * returns a pointer to the block. The managed blocks are
917 * deleted only all at once by the delete_Blocks function.
919 static void *
920 new_Block(size_t size)
922 Blocks *b = &blocks;
924 /* first, get to the end of the linked list */
925 while (b->next)
926 b = b->next;
927 /* now allocate the requested chunk */
928 b->chunk = nasm_malloc(size);
930 /* now allocate a new block for the next request */
931 b->next = nasm_malloc(sizeof(Blocks));
932 /* and initialize the contents of the new block */
933 b->next->next = NULL;
934 b->next->chunk = NULL;
935 return b->chunk;
939 * this function deletes all managed blocks of memory
941 static void
942 delete_Blocks(void)
944 Blocks *a,*b = &blocks;
947 * keep in mind that the first block, pointed to by blocks
948 * is a static and not dynamically allocated, so we don't
949 * free it.
951 while (b)
953 if (b->chunk)
954 nasm_free(b->chunk);
955 a = b;
956 b = b->next;
957 if (a != &blocks)
958 nasm_free(a);
963 * this function creates a new Token and passes a pointer to it
964 * back to the caller. It sets the type and text elements, and
965 * also the mac and next elements to NULL.
967 static Token *
968 new_Token(Token * next, int type, char *text, int txtlen)
970 Token *t;
971 int i;
973 if (freeTokens == NULL)
975 freeTokens = (Token *)new_Block(TOKEN_BLOCKSIZE * sizeof(Token));
976 for (i = 0; i < TOKEN_BLOCKSIZE - 1; i++)
977 freeTokens[i].next = &freeTokens[i + 1];
978 freeTokens[i].next = NULL;
980 t = freeTokens;
981 freeTokens = t->next;
982 t->next = next;
983 t->mac = NULL;
984 t->type = type;
985 if (type == TOK_WHITESPACE || text == NULL)
987 t->text = NULL;
989 else
991 if (txtlen == 0)
992 txtlen = strlen(text);
993 t->text = nasm_malloc(1 + txtlen);
994 strncpy(t->text, text, txtlen);
995 t->text[txtlen] = '\0';
997 return t;
1000 static Token *
1001 delete_Token(Token * t)
1003 Token *next = t->next;
1004 nasm_free(t->text);
1005 t->next = freeTokens;
1006 freeTokens = t;
1007 return next;
1011 * Convert a line of tokens back into text.
1012 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1013 * will be transformed into ..@ctxnum.xxx
1015 static char *
1016 detoken(Token * tlist, int expand_locals)
1018 Token *t;
1019 int len;
1020 char *line, *p;
1022 len = 0;
1023 for (t = tlist; t; t = t->next)
1025 if (t->type == TOK_PREPROC_ID && t->text[1] == '!')
1027 char *p = getenv(t->text + 2);
1028 nasm_free(t->text);
1029 if (p)
1030 t->text = nasm_strdup(p);
1031 else
1032 t->text = NULL;
1034 /* Expand local macros here and not during preprocessing */
1035 if (expand_locals &&
1036 t->type == TOK_PREPROC_ID && t->text &&
1037 t->text[0] == '%' && t->text[1] == '$')
1039 Context *ctx = get_ctx(t->text, FALSE);
1040 if (ctx)
1042 char buffer[40];
1043 char *p, *q = t->text + 2;
1045 q += strspn(q, "$");
1046 sprintf(buffer, "..@%lu.", ctx->number);
1047 p = nasm_strcat(buffer, q);
1048 nasm_free(t->text);
1049 t->text = p;
1052 if (t->type == TOK_WHITESPACE)
1054 len++;
1056 else if (t->text)
1058 len += strlen(t->text);
1061 p = line = nasm_malloc(len + 1);
1062 for (t = tlist; t; t = t->next)
1064 if (t->type == TOK_WHITESPACE)
1066 *p = ' ';
1067 p++;
1068 *p = '\0';
1070 else if (t->text)
1072 strcpy(p, t->text);
1073 p += strlen(p);
1076 *p = '\0';
1077 return line;
1081 * A scanner, suitable for use by the expression evaluator, which
1082 * operates on a line of Tokens. Expects a pointer to a pointer to
1083 * the first token in the line to be passed in as its private_data
1084 * field.
1086 static int
1087 ppscan(void *private_data, struct tokenval *tokval)
1089 Token **tlineptr = private_data;
1090 Token *tline;
1094 tline = *tlineptr;
1095 *tlineptr = tline ? tline->next : NULL;
1097 while (tline && (tline->type == TOK_WHITESPACE ||
1098 tline->type == TOK_COMMENT));
1100 if (!tline)
1101 return tokval->t_type = TOKEN_EOS;
1103 if (tline->text[0] == '$' && !tline->text[1])
1104 return tokval->t_type = TOKEN_HERE;
1105 if (tline->text[0] == '$' && tline->text[1] == '$' && !tline->text[2])
1106 return tokval->t_type = TOKEN_BASE;
1108 if (tline->type == TOK_ID)
1110 tokval->t_charptr = tline->text;
1111 if (tline->text[0] == '$')
1113 tokval->t_charptr++;
1114 return tokval->t_type = TOKEN_ID;
1118 * This is the only special case we actually need to worry
1119 * about in this restricted context.
1121 if (!nasm_stricmp(tline->text, "seg"))
1122 return tokval->t_type = TOKEN_SEG;
1124 return tokval->t_type = TOKEN_ID;
1127 if (tline->type == TOK_NUMBER)
1129 int rn_error;
1131 tokval->t_integer = readnum(tline->text, &rn_error);
1132 if (rn_error)
1133 return tokval->t_type = TOKEN_ERRNUM;
1134 tokval->t_charptr = NULL;
1135 return tokval->t_type = TOKEN_NUM;
1138 if (tline->type == TOK_STRING)
1140 int rn_warn;
1141 char q, *r;
1142 int l;
1144 r = tline->text;
1145 q = *r++;
1146 l = strlen(r);
1148 if (l == 0 || r[l - 1] != q)
1149 return tokval->t_type = TOKEN_ERRNUM;
1150 tokval->t_integer = readstrnum(r, l - 1, &rn_warn);
1151 if (rn_warn)
1152 error(ERR_WARNING | ERR_PASS1, "character constant too long");
1153 tokval->t_charptr = NULL;
1154 return tokval->t_type = TOKEN_NUM;
1157 if (tline->type == TOK_OTHER)
1159 if (!strcmp(tline->text, "<<"))
1160 return tokval->t_type = TOKEN_SHL;
1161 if (!strcmp(tline->text, ">>"))
1162 return tokval->t_type = TOKEN_SHR;
1163 if (!strcmp(tline->text, "//"))
1164 return tokval->t_type = TOKEN_SDIV;
1165 if (!strcmp(tline->text, "%%"))
1166 return tokval->t_type = TOKEN_SMOD;
1167 if (!strcmp(tline->text, "=="))
1168 return tokval->t_type = TOKEN_EQ;
1169 if (!strcmp(tline->text, "<>"))
1170 return tokval->t_type = TOKEN_NE;
1171 if (!strcmp(tline->text, "!="))
1172 return tokval->t_type = TOKEN_NE;
1173 if (!strcmp(tline->text, "<="))
1174 return tokval->t_type = TOKEN_LE;
1175 if (!strcmp(tline->text, ">="))
1176 return tokval->t_type = TOKEN_GE;
1177 if (!strcmp(tline->text, "&&"))
1178 return tokval->t_type = TOKEN_DBL_AND;
1179 if (!strcmp(tline->text, "^^"))
1180 return tokval->t_type = TOKEN_DBL_XOR;
1181 if (!strcmp(tline->text, "||"))
1182 return tokval->t_type = TOKEN_DBL_OR;
1186 * We have no other options: just return the first character of
1187 * the token text.
1189 return tokval->t_type = tline->text[0];
1193 * Compare a string to the name of an existing macro; this is a
1194 * simple wrapper which calls either strcmp or nasm_stricmp
1195 * depending on the value of the `casesense' parameter.
1197 static int
1198 mstrcmp(char *p, char *q, int casesense)
1200 return casesense ? strcmp(p, q) : nasm_stricmp(p, q);
1204 * Return the Context structure associated with a %$ token. Return
1205 * NULL, having _already_ reported an error condition, if the
1206 * context stack isn't deep enough for the supplied number of $
1207 * signs.
1208 * If all_contexts == TRUE, contexts that enclose current are
1209 * also scanned for such smacro, until it is found; if not -
1210 * only the context that directly results from the number of $'s
1211 * in variable's name.
1213 static Context *
1214 get_ctx(char *name, int all_contexts)
1216 Context *ctx;
1217 SMacro *m;
1218 int i;
1220 if (!name || name[0] != '%' || name[1] != '$')
1221 return NULL;
1223 if (!cstk)
1225 error(ERR_NONFATAL, "`%s': context stack is empty", name);
1226 return NULL;
1229 for (i = strspn(name + 2, "$"), ctx = cstk; (i > 0) && ctx; i--)
1231 ctx = ctx->next;
1232 /* i--; Lino - 02/25/02 */
1234 if (!ctx)
1236 error(ERR_NONFATAL, "`%s': context stack is only"
1237 " %d level%s deep", name, i - 1, (i == 2 ? "" : "s"));
1238 return NULL;
1240 if (!all_contexts)
1241 return ctx;
1245 /* Search for this smacro in found context */
1246 m = ctx->localmac;
1247 while (m)
1249 if (!mstrcmp(m->name, name, m->casesense))
1250 return ctx;
1251 m = m->next;
1253 ctx = ctx->next;
1255 while (ctx);
1256 return NULL;
1260 * Open an include file. This routine must always return a valid
1261 * file pointer if it returns - it's responsible for throwing an
1262 * ERR_FATAL and bombing out completely if not. It should also try
1263 * the include path one by one until it finds the file or reaches
1264 * the end of the path.
1266 static FILE *
1267 inc_fopen(char *file)
1269 FILE *fp;
1270 char *prefix = "", *combine;
1271 IncPath *ip = ipath;
1272 static int namelen = 0;
1273 int len = strlen(file);
1275 while (1)
1277 combine = nasm_malloc(strlen(prefix) + len + 1);
1278 strcpy(combine, prefix);
1279 strcat(combine, file);
1280 fp = fopen(combine, "r");
1281 if (pass == 0 && fp)
1283 namelen += strlen(combine) + 1;
1284 if (namelen > 62)
1286 printf(" \\\n ");
1287 namelen = 2;
1289 printf(" %s", combine);
1291 nasm_free(combine);
1292 if (fp)
1293 return fp;
1294 if (!ip)
1295 break;
1296 prefix = ip->path;
1297 ip = ip->next;
1300 error(ERR_FATAL, "unable to open include file `%s'", file);
1301 return NULL; /* never reached - placate compilers */
1305 * Determine if we should warn on defining a single-line macro of
1306 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1307 * return TRUE if _any_ single-line macro of that name is defined.
1308 * Otherwise, will return TRUE if a single-line macro with either
1309 * `nparam' or no parameters is defined.
1311 * If a macro with precisely the right number of parameters is
1312 * defined, or nparam is -1, the address of the definition structure
1313 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1314 * is NULL, no action will be taken regarding its contents, and no
1315 * error will occur.
1317 * Note that this is also called with nparam zero to resolve
1318 * `ifdef'.
1320 * If you already know which context macro belongs to, you can pass
1321 * the context pointer as first parameter; if you won't but name begins
1322 * with %$ the context will be automatically computed. If all_contexts
1323 * is true, macro will be searched in outer contexts as well.
1325 static int
1326 smacro_defined(Context * ctx, char *name, int nparam, SMacro ** defn,
1327 int nocase)
1329 SMacro *m;
1331 if (ctx)
1332 m = ctx->localmac;
1333 else if (name[0] == '%' && name[1] == '$')
1335 if (cstk)
1336 ctx = get_ctx(name, FALSE);
1337 if (!ctx)
1338 return FALSE; /* got to return _something_ */
1339 m = ctx->localmac;
1341 else
1342 m = smacros[hash(name)];
1344 while (m)
1346 if (!mstrcmp(m->name, name, m->casesense && nocase) &&
1347 (nparam <= 0 || m->nparam == 0 || nparam == m->nparam))
1349 if (defn)
1351 if (nparam == m->nparam || nparam == -1)
1352 *defn = m;
1353 else
1354 *defn = NULL;
1356 return TRUE;
1358 m = m->next;
1361 return FALSE;
1365 * Count and mark off the parameters in a multi-line macro call.
1366 * This is called both from within the multi-line macro expansion
1367 * code, and also to mark off the default parameters when provided
1368 * in a %macro definition line.
1370 static void
1371 count_mmac_params(Token * t, int *nparam, Token *** params)
1373 int paramsize, brace;
1375 *nparam = paramsize = 0;
1376 *params = NULL;
1377 while (t)
1379 if (*nparam >= paramsize)
1381 paramsize += PARAM_DELTA;
1382 *params = nasm_realloc(*params, sizeof(**params) * paramsize);
1384 skip_white_(t);
1385 brace = FALSE;
1386 if (tok_is_(t, "{"))
1387 brace = TRUE;
1388 (*params)[(*nparam)++] = t;
1389 while (tok_isnt_(t, brace ? "}" : ","))
1390 t = t->next;
1391 if (t)
1392 { /* got a comma/brace */
1393 t = t->next;
1394 if (brace)
1397 * Now we've found the closing brace, look further
1398 * for the comma.
1400 skip_white_(t);
1401 if (tok_isnt_(t, ","))
1403 error(ERR_NONFATAL,
1404 "braces do not enclose all of macro parameter");
1405 while (tok_isnt_(t, ","))
1406 t = t->next;
1408 if (t)
1409 t = t->next; /* eat the comma */
1416 * Determine whether one of the various `if' conditions is true or
1417 * not.
1419 * We must free the tline we get passed.
1421 static int
1422 if_condition(Token * tline, int i)
1424 int j, casesense;
1425 Token *t, *tt, **tptr, *origline;
1426 struct tokenval tokval;
1427 expr *evalresult;
1429 origline = tline;
1431 switch (i)
1433 case PP_IFCTX:
1434 case PP_ELIFCTX:
1435 case PP_IFNCTX:
1436 case PP_ELIFNCTX:
1437 j = FALSE; /* have we matched yet? */
1438 while (cstk && tline)
1440 skip_white_(tline);
1441 if (!tline || tline->type != TOK_ID)
1443 error(ERR_NONFATAL,
1444 "`%s' expects context identifiers",
1445 directives[i]);
1446 free_tlist(origline);
1447 return -1;
1449 if (!nasm_stricmp(tline->text, cstk->name))
1450 j = TRUE;
1451 tline = tline->next;
1453 if (i == PP_IFNCTX || i == PP_ELIFNCTX)
1454 j = !j;
1455 free_tlist(origline);
1456 return j;
1458 case PP_IFDEF:
1459 case PP_ELIFDEF:
1460 case PP_IFNDEF:
1461 case PP_ELIFNDEF:
1462 j = FALSE; /* have we matched yet? */
1463 while (tline)
1465 skip_white_(tline);
1466 if (!tline || (tline->type != TOK_ID &&
1467 (tline->type != TOK_PREPROC_ID ||
1468 tline->text[1] != '$')))
1470 error(ERR_NONFATAL,
1471 "`%s' expects macro identifiers",
1472 directives[i]);
1473 free_tlist(origline);
1474 return -1;
1476 if (smacro_defined(NULL, tline->text, 0, NULL, 1))
1477 j = TRUE;
1478 tline = tline->next;
1480 if (i == PP_IFNDEF || i == PP_ELIFNDEF)
1481 j = !j;
1482 free_tlist(origline);
1483 return j;
1485 case PP_IFIDN:
1486 case PP_ELIFIDN:
1487 case PP_IFNIDN:
1488 case PP_ELIFNIDN:
1489 case PP_IFIDNI:
1490 case PP_ELIFIDNI:
1491 case PP_IFNIDNI:
1492 case PP_ELIFNIDNI:
1493 tline = expand_smacro(tline);
1494 t = tt = tline;
1495 while (tok_isnt_(tt, ","))
1496 tt = tt->next;
1497 if (!tt)
1499 error(ERR_NONFATAL,
1500 "`%s' expects two comma-separated arguments",
1501 directives[i]);
1502 free_tlist(tline);
1503 return -1;
1505 tt = tt->next;
1506 casesense = (i == PP_IFIDN || i == PP_ELIFIDN ||
1507 i == PP_IFNIDN || i == PP_ELIFNIDN);
1508 j = TRUE; /* assume equality unless proved not */
1509 while ((t->type != TOK_OTHER || strcmp(t->text, ",")) && tt)
1511 if (tt->type == TOK_OTHER && !strcmp(tt->text, ","))
1513 error(ERR_NONFATAL, "`%s': more than one comma on line",
1514 directives[i]);
1515 free_tlist(tline);
1516 return -1;
1518 if (t->type == TOK_WHITESPACE)
1520 t = t->next;
1521 continue;
1523 else if (tt->type == TOK_WHITESPACE)
1525 tt = tt->next;
1526 continue;
1528 else if (tt->type != t->type ||
1529 mstrcmp(tt->text, t->text, casesense))
1531 j = FALSE; /* found mismatching tokens */
1532 break;
1534 else
1536 t = t->next;
1537 tt = tt->next;
1538 continue;
1541 if ((t->type != TOK_OTHER || strcmp(t->text, ",")) || tt)
1542 j = FALSE; /* trailing gunk on one end or other */
1543 if (i == PP_IFNIDN || i == PP_ELIFNIDN ||
1544 i == PP_IFNIDNI || i == PP_ELIFNIDNI)
1545 j = !j;
1546 free_tlist(tline);
1547 return j;
1549 case PP_IFMACRO:
1550 case PP_ELIFMACRO:
1551 case PP_IFNMACRO:
1552 case PP_ELIFNMACRO:
1554 int found = 0;
1555 MMacro searching, *mmac;
1557 tline = tline->next;
1558 skip_white_(tline);
1559 tline = expand_id(tline);
1560 if (!tok_type_(tline, TOK_ID))
1562 error(ERR_NONFATAL,
1563 "`%s' expects a macro name",
1564 directives[i]);
1565 return -1;
1567 searching.name = nasm_strdup(tline->text);
1568 searching.casesense = (i == PP_MACRO);
1569 searching.plus = FALSE;
1570 searching.nolist = FALSE;
1571 searching.in_progress = FALSE;
1572 searching.rep_nest = NULL;
1573 searching.nparam_min = 0;
1574 searching.nparam_max = INT_MAX;
1575 tline = expand_smacro(tline->next);
1576 skip_white_(tline);
1577 if (!tline)
1579 } else if (!tok_type_(tline, TOK_NUMBER))
1581 error(ERR_NONFATAL,
1582 "`%s' expects a parameter count or nothing",
1583 directives[i]);
1585 else
1587 searching.nparam_min = searching.nparam_max =
1588 readnum(tline->text, &j);
1589 if (j)
1590 error(ERR_NONFATAL,
1591 "unable to parse parameter count `%s'",
1592 tline->text);
1594 if (tline && tok_is_(tline->next, "-"))
1596 tline = tline->next->next;
1597 if (tok_is_(tline, "*"))
1598 searching.nparam_max = INT_MAX;
1599 else if (!tok_type_(tline, TOK_NUMBER))
1600 error(ERR_NONFATAL,
1601 "`%s' expects a parameter count after `-'",
1602 directives[i]);
1603 else
1605 searching.nparam_max = readnum(tline->text, &j);
1606 if (j)
1607 error(ERR_NONFATAL,
1608 "unable to parse parameter count `%s'",
1609 tline->text);
1610 if (searching.nparam_min > searching.nparam_max)
1611 error(ERR_NONFATAL,
1612 "minimum parameter count exceeds maximum");
1615 if (tline && tok_is_(tline->next, "+"))
1617 tline = tline->next;
1618 searching.plus = TRUE;
1620 mmac = mmacros[hash(searching.name)];
1621 while (mmac)
1623 if (!strcmp(mmac->name, searching.name) &&
1624 (mmac->nparam_min <= searching.nparam_max
1625 || searching.plus)
1626 && (searching.nparam_min <= mmac->nparam_max
1627 || mmac->plus))
1629 found = TRUE;
1630 break;
1632 mmac = mmac->next;
1634 nasm_free(searching.name);
1635 free_tlist(origline);
1636 if (i == PP_IFNMACRO || i == PP_ELIFNMACRO)
1637 found = !found;
1638 return found;
1641 case PP_IFID:
1642 case PP_ELIFID:
1643 case PP_IFNID:
1644 case PP_ELIFNID:
1645 case PP_IFNUM:
1646 case PP_ELIFNUM:
1647 case PP_IFNNUM:
1648 case PP_ELIFNNUM:
1649 case PP_IFSTR:
1650 case PP_ELIFSTR:
1651 case PP_IFNSTR:
1652 case PP_ELIFNSTR:
1653 tline = expand_smacro(tline);
1654 t = tline;
1655 while (tok_type_(t, TOK_WHITESPACE))
1656 t = t->next;
1657 j = FALSE; /* placate optimiser */
1658 if (t)
1659 switch (i)
1661 case PP_IFID:
1662 case PP_ELIFID:
1663 case PP_IFNID:
1664 case PP_ELIFNID:
1665 j = (t->type == TOK_ID);
1666 break;
1667 case PP_IFNUM:
1668 case PP_ELIFNUM:
1669 case PP_IFNNUM:
1670 case PP_ELIFNNUM:
1671 j = (t->type == TOK_NUMBER);
1672 break;
1673 case PP_IFSTR:
1674 case PP_ELIFSTR:
1675 case PP_IFNSTR:
1676 case PP_ELIFNSTR:
1677 j = (t->type == TOK_STRING);
1678 break;
1680 if (i == PP_IFNID || i == PP_ELIFNID ||
1681 i == PP_IFNNUM || i == PP_ELIFNNUM ||
1682 i == PP_IFNSTR || i == PP_ELIFNSTR)
1683 j = !j;
1684 free_tlist(tline);
1685 return j;
1687 case PP_IF:
1688 case PP_ELIF:
1689 t = tline = expand_smacro(tline);
1690 tptr = &t;
1691 tokval.t_type = TOKEN_INVALID;
1692 evalresult = evaluate(ppscan, tptr, &tokval,
1693 NULL, pass | CRITICAL, error, NULL);
1694 free_tlist(tline);
1695 if (!evalresult)
1696 return -1;
1697 if (tokval.t_type)
1698 error(ERR_WARNING,
1699 "trailing garbage after expression ignored");
1700 if (!is_simple(evalresult))
1702 error(ERR_NONFATAL,
1703 "non-constant value given to `%s'", directives[i]);
1704 return -1;
1706 return reloc_value(evalresult) != 0;
1708 default:
1709 error(ERR_FATAL,
1710 "preprocessor directive `%s' not yet implemented",
1711 directives[i]);
1712 free_tlist(origline);
1713 return -1; /* yeah, right */
1718 * Expand macros in a string. Used in %error and %include directives.
1719 * First tokenise the string, apply "expand_smacro" and then de-tokenise back.
1720 * The returned variable should ALWAYS be freed after usage.
1722 void
1723 expand_macros_in_string(char **p)
1725 Token *line = tokenise(*p);
1726 line = expand_smacro(line);
1727 *p = detoken(line, FALSE);
1731 * find and process preprocessor directive in passed line
1732 * Find out if a line contains a preprocessor directive, and deal
1733 * with it if so.
1735 * If a directive _is_ found, it is the responsibility of this routine
1736 * (and not the caller) to free_tlist() the line.
1738 * @param tline a pointer to the current tokeninzed line linked list
1739 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
1742 static int
1743 do_directive(Token * tline)
1745 int i, j, k, m, nparam, nolist;
1746 int offset;
1747 char *p, *mname;
1748 Include *inc;
1749 Context *ctx;
1750 Cond *cond;
1751 SMacro *smac, **smhead;
1752 MMacro *mmac;
1753 Token *t, *tt, *param_start, *macro_start, *last, **tptr, *origline;
1754 Line *l;
1755 struct tokenval tokval;
1756 expr *evalresult;
1757 MMacro *tmp_defining; /* Used when manipulating rep_nest */
1759 origline = tline;
1761 skip_white_(tline);
1762 if (!tok_type_(tline, TOK_PREPROC_ID) ||
1763 (tline->text[1] == '%' || tline->text[1] == '$'
1764 || tline->text[1] == '!'))
1765 return NO_DIRECTIVE_FOUND;
1767 i = -1;
1768 j = elements(directives);
1769 while (j - i > 1)
1771 k = (j + i) / 2;
1772 m = nasm_stricmp(tline->text, directives[k]);
1773 if (m == 0) {
1774 if (tasm_compatible_mode) {
1775 i = k;
1776 j = -2;
1777 } else if (k != PP_ARG && k != PP_LOCAL && k != PP_STACKSIZE) {
1778 i = k;
1779 j = -2;
1781 break;
1783 else if (m < 0) {
1784 j = k;
1786 else
1787 i = k;
1791 * If we're in a non-emitting branch of a condition construct,
1792 * or walking to the end of an already terminated %rep block,
1793 * we should ignore all directives except for condition
1794 * directives.
1796 if (((istk->conds && !emitting(istk->conds->state)) ||
1797 (istk->mstk && !istk->mstk->in_progress)) &&
1798 !is_condition(i))
1800 return NO_DIRECTIVE_FOUND;
1804 * If we're defining a macro or reading a %rep block, we should
1805 * ignore all directives except for %macro/%imacro (which
1806 * generate an error), %endm/%endmacro, and (only if we're in a
1807 * %rep block) %endrep. If we're in a %rep block, another %rep
1808 * causes an error, so should be let through.
1810 if (defining && i != PP_MACRO && i != PP_IMACRO &&
1811 i != PP_ENDMACRO && i != PP_ENDM &&
1812 (defining->name || (i != PP_ENDREP && i != PP_REP)))
1814 return NO_DIRECTIVE_FOUND;
1817 if (j != -2)
1819 error(ERR_NONFATAL, "unknown preprocessor directive `%s'",
1820 tline->text);
1821 return NO_DIRECTIVE_FOUND; /* didn't get it */
1824 switch (i)
1826 case PP_STACKSIZE:
1827 /* Directive to tell NASM what the default stack size is. The
1828 * default is for a 16-bit stack, and this can be overriden with
1829 * %stacksize large.
1830 * the following form:
1832 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1834 tline = tline->next;
1835 if (tline && tline->type == TOK_WHITESPACE)
1836 tline = tline->next;
1837 if (!tline || tline->type != TOK_ID)
1839 error(ERR_NONFATAL, "`%%stacksize' missing size parameter");
1840 free_tlist(origline);
1841 return DIRECTIVE_FOUND;
1843 if (nasm_stricmp(tline->text, "flat") == 0)
1845 /* All subsequent ARG directives are for a 32-bit stack */
1846 StackSize = 4;
1847 StackPointer = "ebp";
1848 ArgOffset = 8;
1849 LocalOffset = 4;
1851 else if (nasm_stricmp(tline->text, "large") == 0)
1853 /* All subsequent ARG directives are for a 16-bit stack,
1854 * far function call.
1856 StackSize = 2;
1857 StackPointer = "bp";
1858 ArgOffset = 4;
1859 LocalOffset = 2;
1861 else if (nasm_stricmp(tline->text, "small") == 0)
1863 /* All subsequent ARG directives are for a 16-bit stack,
1864 * far function call. We don't support near functions.
1866 StackSize = 2;
1867 StackPointer = "bp";
1868 ArgOffset = 6;
1869 LocalOffset = 2;
1871 else
1873 error(ERR_NONFATAL, "`%%stacksize' invalid size type");
1874 free_tlist(origline);
1875 return DIRECTIVE_FOUND;
1877 free_tlist(origline);
1878 return DIRECTIVE_FOUND;
1880 case PP_ARG:
1881 /* TASM like ARG directive to define arguments to functions, in
1882 * the following form:
1884 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1886 offset = ArgOffset;
1889 char *arg, directive[256];
1890 int size = StackSize;
1892 /* Find the argument name */
1893 tline = tline->next;
1894 if (tline && tline->type == TOK_WHITESPACE)
1895 tline = tline->next;
1896 if (!tline || tline->type != TOK_ID)
1898 error(ERR_NONFATAL, "`%%arg' missing argument parameter");
1899 free_tlist(origline);
1900 return DIRECTIVE_FOUND;
1902 arg = tline->text;
1904 /* Find the argument size type */
1905 tline = tline->next;
1906 if (!tline || tline->type != TOK_OTHER
1907 || tline->text[0] != ':')
1909 error(ERR_NONFATAL,
1910 "Syntax error processing `%%arg' directive");
1911 free_tlist(origline);
1912 return DIRECTIVE_FOUND;
1914 tline = tline->next;
1915 if (!tline || tline->type != TOK_ID)
1917 error(ERR_NONFATAL,
1918 "`%%arg' missing size type parameter");
1919 free_tlist(origline);
1920 return DIRECTIVE_FOUND;
1923 /* Allow macro expansion of type parameter */
1924 tt = tokenise(tline->text);
1925 tt = expand_smacro(tt);
1926 if (nasm_stricmp(tt->text, "byte") == 0)
1928 size = MAX(StackSize, 1);
1930 else if (nasm_stricmp(tt->text, "word") == 0)
1932 size = MAX(StackSize, 2);
1934 else if (nasm_stricmp(tt->text, "dword") == 0)
1936 size = MAX(StackSize, 4);
1938 else if (nasm_stricmp(tt->text, "qword") == 0)
1940 size = MAX(StackSize, 8);
1942 else if (nasm_stricmp(tt->text, "tword") == 0)
1944 size = MAX(StackSize, 10);
1946 else
1948 error(ERR_NONFATAL,
1949 "Invalid size type for `%%arg' missing directive");
1950 free_tlist(tt);
1951 free_tlist(origline);
1952 return DIRECTIVE_FOUND;
1954 free_tlist(tt);
1956 /* Now define the macro for the argument */
1957 sprintf(directive, "%%define %s (%s+%d)", arg, StackPointer,
1958 offset);
1959 do_directive(tokenise(directive));
1960 offset += size;
1962 /* Move to the next argument in the list */
1963 tline = tline->next;
1964 if (tline && tline->type == TOK_WHITESPACE)
1965 tline = tline->next;
1967 while (tline && tline->type == TOK_OTHER
1968 && tline->text[0] == ',');
1969 free_tlist(origline);
1970 return DIRECTIVE_FOUND;
1972 case PP_LOCAL:
1973 /* TASM like LOCAL directive to define local variables for a
1974 * function, in the following form:
1976 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
1978 * The '= LocalSize' at the end is ignored by NASM, but is
1979 * required by TASM to define the local parameter size (and used
1980 * by the TASM macro package).
1982 offset = LocalOffset;
1985 char *local, directive[256];
1986 int size = StackSize;
1988 /* Find the argument name */
1989 tline = tline->next;
1990 if (tline && tline->type == TOK_WHITESPACE)
1991 tline = tline->next;
1992 if (!tline || tline->type != TOK_ID)
1994 error(ERR_NONFATAL,
1995 "`%%local' missing argument parameter");
1996 free_tlist(origline);
1997 return DIRECTIVE_FOUND;
1999 local = tline->text;
2001 /* Find the argument size type */
2002 tline = tline->next;
2003 if (!tline || tline->type != TOK_OTHER
2004 || tline->text[0] != ':')
2006 error(ERR_NONFATAL,
2007 "Syntax error processing `%%local' directive");
2008 free_tlist(origline);
2009 return DIRECTIVE_FOUND;
2011 tline = tline->next;
2012 if (!tline || tline->type != TOK_ID)
2014 error(ERR_NONFATAL,
2015 "`%%local' missing size type parameter");
2016 free_tlist(origline);
2017 return DIRECTIVE_FOUND;
2020 /* Allow macro expansion of type parameter */
2021 tt = tokenise(tline->text);
2022 tt = expand_smacro(tt);
2023 if (nasm_stricmp(tt->text, "byte") == 0)
2025 size = MAX(StackSize, 1);
2027 else if (nasm_stricmp(tt->text, "word") == 0)
2029 size = MAX(StackSize, 2);
2031 else if (nasm_stricmp(tt->text, "dword") == 0)
2033 size = MAX(StackSize, 4);
2035 else if (nasm_stricmp(tt->text, "qword") == 0)
2037 size = MAX(StackSize, 8);
2039 else if (nasm_stricmp(tt->text, "tword") == 0)
2041 size = MAX(StackSize, 10);
2043 else
2045 error(ERR_NONFATAL,
2046 "Invalid size type for `%%local' missing directive");
2047 free_tlist(tt);
2048 free_tlist(origline);
2049 return DIRECTIVE_FOUND;
2051 free_tlist(tt);
2053 /* Now define the macro for the argument */
2054 sprintf(directive, "%%define %s (%s-%d)", local, StackPointer,
2055 offset);
2056 do_directive(tokenise(directive));
2057 offset += size;
2059 /* Now define the assign to setup the enter_c macro correctly */
2060 sprintf(directive, "%%assign %%$localsize %%$localsize+%d",
2061 size);
2062 do_directive(tokenise(directive));
2064 /* Move to the next argument in the list */
2065 tline = tline->next;
2066 if (tline && tline->type == TOK_WHITESPACE)
2067 tline = tline->next;
2069 while (tline && tline->type == TOK_OTHER
2070 && tline->text[0] == ',');
2071 free_tlist(origline);
2072 return DIRECTIVE_FOUND;
2074 case PP_CLEAR:
2075 if (tline->next)
2076 error(ERR_WARNING,
2077 "trailing garbage after `%%clear' ignored");
2078 for (j = 0; j < NHASH; j++)
2080 while (mmacros[j])
2082 MMacro *m = mmacros[j];
2083 mmacros[j] = m->next;
2084 free_mmacro(m);
2086 while (smacros[j])
2088 SMacro *s = smacros[j];
2089 smacros[j] = smacros[j]->next;
2090 nasm_free(s->name);
2091 free_tlist(s->expansion);
2092 nasm_free(s);
2095 free_tlist(origline);
2096 return DIRECTIVE_FOUND;
2098 case PP_INCLUDE:
2099 tline = tline->next;
2100 skip_white_(tline);
2101 if (!tline || (tline->type != TOK_STRING &&
2102 tline->type != TOK_INTERNAL_STRING))
2104 error(ERR_NONFATAL, "`%%include' expects a file name");
2105 free_tlist(origline);
2106 return DIRECTIVE_FOUND; /* but we did _something_ */
2108 if (tline->next)
2109 error(ERR_WARNING,
2110 "trailing garbage after `%%include' ignored");
2111 if (tline->type != TOK_INTERNAL_STRING)
2113 p = tline->text + 1; /* point past the quote to the name */
2114 p[strlen(p) - 1] = '\0'; /* remove the trailing quote */
2116 else
2117 p = tline->text; /* internal_string is easier */
2118 expand_macros_in_string(&p);
2119 inc = nasm_malloc(sizeof(Include));
2120 inc->next = istk;
2121 inc->conds = NULL;
2122 inc->fp = inc_fopen(p);
2123 inc->fname = src_set_fname(p);
2124 inc->lineno = src_set_linnum(0);
2125 inc->lineinc = 1;
2126 inc->expansion = NULL;
2127 inc->mstk = NULL;
2128 istk = inc;
2129 list->uplevel(LIST_INCLUDE);
2130 free_tlist(origline);
2131 return DIRECTIVE_FOUND;
2133 case PP_PUSH:
2134 tline = tline->next;
2135 skip_white_(tline);
2136 tline = expand_id(tline);
2137 if (!tok_type_(tline, TOK_ID))
2139 error(ERR_NONFATAL, "`%%push' expects a context identifier");
2140 free_tlist(origline);
2141 return DIRECTIVE_FOUND; /* but we did _something_ */
2143 if (tline->next)
2144 error(ERR_WARNING, "trailing garbage after `%%push' ignored");
2145 ctx = nasm_malloc(sizeof(Context));
2146 ctx->next = cstk;
2147 ctx->localmac = NULL;
2148 ctx->name = nasm_strdup(tline->text);
2149 ctx->number = unique++;
2150 cstk = ctx;
2151 free_tlist(origline);
2152 break;
2154 case PP_REPL:
2155 tline = tline->next;
2156 skip_white_(tline);
2157 tline = expand_id(tline);
2158 if (!tok_type_(tline, TOK_ID))
2160 error(ERR_NONFATAL, "`%%repl' expects a context identifier");
2161 free_tlist(origline);
2162 return DIRECTIVE_FOUND; /* but we did _something_ */
2164 if (tline->next)
2165 error(ERR_WARNING, "trailing garbage after `%%repl' ignored");
2166 if (!cstk)
2167 error(ERR_NONFATAL, "`%%repl': context stack is empty");
2168 else
2170 nasm_free(cstk->name);
2171 cstk->name = nasm_strdup(tline->text);
2173 free_tlist(origline);
2174 break;
2176 case PP_POP:
2177 if (tline->next)
2178 error(ERR_WARNING, "trailing garbage after `%%pop' ignored");
2179 if (!cstk)
2180 error(ERR_NONFATAL,
2181 "`%%pop': context stack is already empty");
2182 else
2183 ctx_pop();
2184 free_tlist(origline);
2185 break;
2187 case PP_ERROR:
2188 tline->next = expand_smacro(tline->next);
2189 tline = tline->next;
2190 skip_white_(tline);
2191 if (tok_type_(tline, TOK_STRING))
2193 p = tline->text + 1; /* point past the quote to the name */
2194 p[strlen(p) - 1] = '\0'; /* remove the trailing quote */
2195 expand_macros_in_string(&p);
2196 error(ERR_NONFATAL, "%s", p);
2197 nasm_free(p);
2199 else
2201 p = detoken(tline, FALSE);
2202 error(ERR_WARNING, "%s", p);
2203 nasm_free(p);
2205 free_tlist(origline);
2206 break;
2208 case PP_IF:
2209 case PP_IFCTX:
2210 case PP_IFDEF:
2211 case PP_IFID:
2212 case PP_IFIDN:
2213 case PP_IFIDNI:
2214 case PP_IFMACRO:
2215 case PP_IFNCTX:
2216 case PP_IFNDEF:
2217 case PP_IFNID:
2218 case PP_IFNIDN:
2219 case PP_IFNIDNI:
2220 case PP_IFNMACRO:
2221 case PP_IFNNUM:
2222 case PP_IFNSTR:
2223 case PP_IFNUM:
2224 case PP_IFSTR:
2225 if (istk->conds && !emitting(istk->conds->state))
2226 j = COND_NEVER;
2227 else
2229 j = if_condition(tline->next, i);
2230 tline->next = NULL; /* it got freed */
2231 free_tlist(origline);
2232 j = j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2234 cond = nasm_malloc(sizeof(Cond));
2235 cond->next = istk->conds;
2236 cond->state = j;
2237 istk->conds = cond;
2238 return DIRECTIVE_FOUND;
2240 case PP_ELIF:
2241 case PP_ELIFCTX:
2242 case PP_ELIFDEF:
2243 case PP_ELIFID:
2244 case PP_ELIFIDN:
2245 case PP_ELIFIDNI:
2246 case PP_ELIFMACRO:
2247 case PP_ELIFNCTX:
2248 case PP_ELIFNDEF:
2249 case PP_ELIFNID:
2250 case PP_ELIFNIDN:
2251 case PP_ELIFNIDNI:
2252 case PP_ELIFNMACRO:
2253 case PP_ELIFNNUM:
2254 case PP_ELIFNSTR:
2255 case PP_ELIFNUM:
2256 case PP_ELIFSTR:
2257 if (!istk->conds)
2258 error(ERR_FATAL, "`%s': no matching `%%if'", directives[i]);
2259 if (emitting(istk->conds->state)
2260 || istk->conds->state == COND_NEVER)
2261 istk->conds->state = COND_NEVER;
2262 else
2265 * IMPORTANT: In the case of %if, we will already have
2266 * called expand_mmac_params(); however, if we're
2267 * processing an %elif we must have been in a
2268 * non-emitting mode, which would have inhibited
2269 * the normal invocation of expand_mmac_params(). Therefore,
2270 * we have to do it explicitly here.
2272 j = if_condition(expand_mmac_params(tline->next), i);
2273 tline->next = NULL; /* it got freed */
2274 free_tlist(origline);
2275 istk->conds->state =
2276 j < 0 ? COND_NEVER : j ? COND_IF_TRUE : COND_IF_FALSE;
2278 return DIRECTIVE_FOUND;
2280 case PP_ELSE:
2281 if (tline->next)
2282 error(ERR_WARNING, "trailing garbage after `%%else' ignored");
2283 if (!istk->conds)
2284 error(ERR_FATAL, "`%%else': no matching `%%if'");
2285 if (emitting(istk->conds->state)
2286 || istk->conds->state == COND_NEVER)
2287 istk->conds->state = COND_ELSE_FALSE;
2288 else
2289 istk->conds->state = COND_ELSE_TRUE;
2290 free_tlist(origline);
2291 return DIRECTIVE_FOUND;
2293 case PP_ENDIF:
2294 if (tline->next)
2295 error(ERR_WARNING,
2296 "trailing garbage after `%%endif' ignored");
2297 if (!istk->conds)
2298 error(ERR_FATAL, "`%%endif': no matching `%%if'");
2299 cond = istk->conds;
2300 istk->conds = cond->next;
2301 nasm_free(cond);
2302 free_tlist(origline);
2303 return DIRECTIVE_FOUND;
2305 case PP_MACRO:
2306 case PP_IMACRO:
2307 if (defining)
2308 error(ERR_FATAL,
2309 "`%%%smacro': already defining a macro",
2310 (i == PP_IMACRO ? "i" : ""));
2311 tline = tline->next;
2312 skip_white_(tline);
2313 tline = expand_id(tline);
2314 if (!tok_type_(tline, TOK_ID))
2316 error(ERR_NONFATAL,
2317 "`%%%smacro' expects a macro name",
2318 (i == PP_IMACRO ? "i" : ""));
2319 return DIRECTIVE_FOUND;
2321 defining = nasm_malloc(sizeof(MMacro));
2322 defining->name = nasm_strdup(tline->text);
2323 defining->casesense = (i == PP_MACRO);
2324 defining->plus = FALSE;
2325 defining->nolist = FALSE;
2326 defining->in_progress = FALSE;
2327 defining->rep_nest = NULL;
2328 tline = expand_smacro(tline->next);
2329 skip_white_(tline);
2330 if (!tok_type_(tline, TOK_NUMBER))
2332 error(ERR_NONFATAL,
2333 "`%%%smacro' expects a parameter count",
2334 (i == PP_IMACRO ? "i" : ""));
2335 defining->nparam_min = defining->nparam_max = 0;
2337 else
2339 defining->nparam_min = defining->nparam_max =
2340 readnum(tline->text, &j);
2341 if (j)
2342 error(ERR_NONFATAL,
2343 "unable to parse parameter count `%s'",
2344 tline->text);
2346 if (tline && tok_is_(tline->next, "-"))
2348 tline = tline->next->next;
2349 if (tok_is_(tline, "*"))
2350 defining->nparam_max = INT_MAX;
2351 else if (!tok_type_(tline, TOK_NUMBER))
2352 error(ERR_NONFATAL,
2353 "`%%%smacro' expects a parameter count after `-'",
2354 (i == PP_IMACRO ? "i" : ""));
2355 else
2357 defining->nparam_max = readnum(tline->text, &j);
2358 if (j)
2359 error(ERR_NONFATAL,
2360 "unable to parse parameter count `%s'",
2361 tline->text);
2362 if (defining->nparam_min > defining->nparam_max)
2363 error(ERR_NONFATAL,
2364 "minimum parameter count exceeds maximum");
2367 if (tline && tok_is_(tline->next, "+"))
2369 tline = tline->next;
2370 defining->plus = TRUE;
2372 if (tline && tok_type_(tline->next, TOK_ID) &&
2373 !nasm_stricmp(tline->next->text, ".nolist"))
2375 tline = tline->next;
2376 defining->nolist = TRUE;
2378 mmac = mmacros[hash(defining->name)];
2379 while (mmac)
2381 if (!strcmp(mmac->name, defining->name) &&
2382 (mmac->nparam_min <= defining->nparam_max
2383 || defining->plus)
2384 && (defining->nparam_min <= mmac->nparam_max
2385 || mmac->plus))
2387 error(ERR_WARNING,
2388 "redefining multi-line macro `%s'",
2389 defining->name);
2390 break;
2392 mmac = mmac->next;
2395 * Handle default parameters.
2397 if (tline && tline->next)
2399 defining->dlist = tline->next;
2400 tline->next = NULL;
2401 count_mmac_params(defining->dlist, &defining->ndefs,
2402 &defining->defaults);
2404 else
2406 defining->dlist = NULL;
2407 defining->defaults = NULL;
2409 defining->expansion = NULL;
2410 free_tlist(origline);
2411 return DIRECTIVE_FOUND;
2413 case PP_ENDM:
2414 case PP_ENDMACRO:
2415 if (!defining)
2417 error(ERR_NONFATAL, "`%s': not defining a macro",
2418 tline->text);
2419 return DIRECTIVE_FOUND;
2421 k = hash(defining->name);
2422 defining->next = mmacros[k];
2423 mmacros[k] = defining;
2424 defining = NULL;
2425 free_tlist(origline);
2426 return DIRECTIVE_FOUND;
2428 case PP_ROTATE:
2429 if (tline->next && tline->next->type == TOK_WHITESPACE)
2430 tline = tline->next;
2431 if (tline->next == NULL)
2433 free_tlist(origline);
2434 error(ERR_NONFATAL, "`%%rotate' missing rotate count");
2435 return DIRECTIVE_FOUND;
2437 t = expand_smacro(tline->next);
2438 tline->next = NULL;
2439 free_tlist(origline);
2440 tline = t;
2441 tptr = &t;
2442 tokval.t_type = TOKEN_INVALID;
2443 evalresult =
2444 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2445 free_tlist(tline);
2446 if (!evalresult)
2447 return DIRECTIVE_FOUND;
2448 if (tokval.t_type)
2449 error(ERR_WARNING,
2450 "trailing garbage after expression ignored");
2451 if (!is_simple(evalresult))
2453 error(ERR_NONFATAL, "non-constant value given to `%%rotate'");
2454 return DIRECTIVE_FOUND;
2456 mmac = istk->mstk;
2457 while (mmac && !mmac->name) /* avoid mistaking %reps for macros */
2458 mmac = mmac->next_active;
2459 if (!mmac)
2461 error(ERR_NONFATAL,
2462 "`%%rotate' invoked outside a macro call");
2464 else if (mmac->nparam == 0)
2466 error(ERR_NONFATAL,
2467 "`%%rotate' invoked within macro without parameters");
2469 else
2471 mmac->rotate = mmac->rotate + reloc_value(evalresult);
2473 if (mmac->rotate < 0)
2474 mmac->rotate =
2475 mmac->nparam - (-mmac->rotate) % mmac->nparam;
2476 mmac->rotate %= mmac->nparam;
2478 return DIRECTIVE_FOUND;
2480 case PP_REP:
2481 nolist = FALSE;
2482 tline = tline->next;
2483 if (tline->next && tline->next->type == TOK_WHITESPACE)
2484 tline = tline->next;
2485 if (tline->next && tline->next->type == TOK_ID &&
2486 !nasm_stricmp(tline->next->text, ".nolist"))
2488 tline = tline->next;
2489 nolist = TRUE;
2491 t = expand_smacro(tline->next);
2492 tline->next = NULL;
2493 free_tlist(origline);
2494 tline = t;
2495 tptr = &t;
2496 tokval.t_type = TOKEN_INVALID;
2497 evalresult =
2498 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2499 free_tlist(tline);
2500 if (!evalresult)
2501 return DIRECTIVE_FOUND;
2502 if (tokval.t_type)
2503 error(ERR_WARNING,
2504 "trailing garbage after expression ignored");
2505 if (!is_simple(evalresult))
2507 error(ERR_NONFATAL, "non-constant value given to `%%rep'");
2508 return DIRECTIVE_FOUND;
2510 tmp_defining = defining;
2511 defining = nasm_malloc(sizeof(MMacro));
2512 defining->name = NULL; /* flags this macro as a %rep block */
2513 defining->casesense = 0;
2514 defining->plus = FALSE;
2515 defining->nolist = nolist;
2516 defining->in_progress = reloc_value(evalresult) + 1;
2517 defining->nparam_min = defining->nparam_max = 0;
2518 defining->defaults = NULL;
2519 defining->dlist = NULL;
2520 defining->expansion = NULL;
2521 defining->next_active = istk->mstk;
2522 defining->rep_nest = tmp_defining;
2523 return DIRECTIVE_FOUND;
2525 case PP_ENDREP:
2526 if (!defining || defining->name)
2528 error(ERR_NONFATAL, "`%%endrep': no matching `%%rep'");
2529 return DIRECTIVE_FOUND;
2533 * Now we have a "macro" defined - although it has no name
2534 * and we won't be entering it in the hash tables - we must
2535 * push a macro-end marker for it on to istk->expansion.
2536 * After that, it will take care of propagating itself (a
2537 * macro-end marker line for a macro which is really a %rep
2538 * block will cause the macro to be re-expanded, complete
2539 * with another macro-end marker to ensure the process
2540 * continues) until the whole expansion is forcibly removed
2541 * from istk->expansion by a %exitrep.
2543 l = nasm_malloc(sizeof(Line));
2544 l->next = istk->expansion;
2545 l->finishes = defining;
2546 l->first = NULL;
2547 istk->expansion = l;
2549 istk->mstk = defining;
2551 list->uplevel(defining->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
2552 tmp_defining = defining;
2553 defining = defining->rep_nest;
2554 free_tlist(origline);
2555 return DIRECTIVE_FOUND;
2557 case PP_EXITREP:
2559 * We must search along istk->expansion until we hit a
2560 * macro-end marker for a macro with no name. Then we set
2561 * its `in_progress' flag to 0.
2563 for (l = istk->expansion; l; l = l->next)
2564 if (l->finishes && !l->finishes->name)
2565 break;
2567 if (l)
2568 l->finishes->in_progress = 0;
2569 else
2570 error(ERR_NONFATAL, "`%%exitrep' not within `%%rep' block");
2571 free_tlist(origline);
2572 return DIRECTIVE_FOUND;
2574 case PP_XDEFINE:
2575 case PP_IXDEFINE:
2576 case PP_DEFINE:
2577 case PP_IDEFINE:
2578 tline = tline->next;
2579 skip_white_(tline);
2580 tline = expand_id(tline);
2581 if (!tline || (tline->type != TOK_ID &&
2582 (tline->type != TOK_PREPROC_ID ||
2583 tline->text[1] != '$')))
2585 error(ERR_NONFATAL,
2586 "`%%%s%sdefine' expects a macro identifier",
2587 ((i == PP_IDEFINE || i == PP_IXDEFINE) ? "i" : ""),
2588 ((i == PP_XDEFINE || i == PP_IXDEFINE) ? "x" : ""));
2589 free_tlist(origline);
2590 return DIRECTIVE_FOUND;
2593 ctx = get_ctx(tline->text, FALSE);
2594 if (!ctx)
2595 smhead = &smacros[hash(tline->text)];
2596 else
2597 smhead = &ctx->localmac;
2598 mname = tline->text;
2599 last = tline;
2600 param_start = tline = tline->next;
2601 nparam = 0;
2603 /* Expand the macro definition now for %xdefine and %ixdefine */
2604 if ((i == PP_XDEFINE) || (i == PP_IXDEFINE))
2605 tline = expand_smacro(tline);
2607 if (tok_is_(tline, "("))
2610 * This macro has parameters.
2613 tline = tline->next;
2614 while (1)
2616 skip_white_(tline);
2617 if (!tline)
2619 error(ERR_NONFATAL, "parameter identifier expected");
2620 free_tlist(origline);
2621 return DIRECTIVE_FOUND;
2623 if (tline->type != TOK_ID)
2625 error(ERR_NONFATAL,
2626 "`%s': parameter identifier expected",
2627 tline->text);
2628 free_tlist(origline);
2629 return DIRECTIVE_FOUND;
2631 tline->type = TOK_SMAC_PARAM + nparam++;
2632 tline = tline->next;
2633 skip_white_(tline);
2634 if (tok_is_(tline, ","))
2636 tline = tline->next;
2637 continue;
2639 if (!tok_is_(tline, ")"))
2641 error(ERR_NONFATAL,
2642 "`)' expected to terminate macro template");
2643 free_tlist(origline);
2644 return DIRECTIVE_FOUND;
2646 break;
2648 last = tline;
2649 tline = tline->next;
2651 if (tok_type_(tline, TOK_WHITESPACE))
2652 last = tline, tline = tline->next;
2653 macro_start = NULL;
2654 last->next = NULL;
2655 t = tline;
2656 while (t)
2658 if (t->type == TOK_ID)
2660 for (tt = param_start; tt; tt = tt->next)
2661 if (tt->type >= TOK_SMAC_PARAM &&
2662 !strcmp(tt->text, t->text))
2663 t->type = tt->type;
2665 tt = t->next;
2666 t->next = macro_start;
2667 macro_start = t;
2668 t = tt;
2671 * Good. We now have a macro name, a parameter count, and a
2672 * token list (in reverse order) for an expansion. We ought
2673 * to be OK just to create an SMacro, store it, and let
2674 * free_tlist have the rest of the line (which we have
2675 * carefully re-terminated after chopping off the expansion
2676 * from the end).
2678 if (smacro_defined(ctx, mname, nparam, &smac, i == PP_DEFINE))
2680 if (!smac)
2682 error(ERR_WARNING,
2683 "single-line macro `%s' defined both with and"
2684 " without parameters", mname);
2685 free_tlist(origline);
2686 free_tlist(macro_start);
2687 return DIRECTIVE_FOUND;
2689 else
2692 * We're redefining, so we have to take over an
2693 * existing SMacro structure. This means freeing
2694 * what was already in it.
2696 nasm_free(smac->name);
2697 free_tlist(smac->expansion);
2700 else
2702 smac = nasm_malloc(sizeof(SMacro));
2703 smac->next = *smhead;
2704 *smhead = smac;
2706 smac->name = nasm_strdup(mname);
2707 smac->casesense = ((i == PP_DEFINE) || (i == PP_XDEFINE));
2708 smac->nparam = nparam;
2709 smac->expansion = macro_start;
2710 smac->in_progress = FALSE;
2711 free_tlist(origline);
2712 return DIRECTIVE_FOUND;
2714 case PP_UNDEF:
2715 tline = tline->next;
2716 skip_white_(tline);
2717 tline = expand_id(tline);
2718 if (!tline || (tline->type != TOK_ID &&
2719 (tline->type != TOK_PREPROC_ID ||
2720 tline->text[1] != '$')))
2722 error(ERR_NONFATAL, "`%%undef' expects a macro identifier");
2723 free_tlist(origline);
2724 return DIRECTIVE_FOUND;
2726 if (tline->next)
2728 error(ERR_WARNING,
2729 "trailing garbage after macro name ignored");
2732 /* Find the context that symbol belongs to */
2733 ctx = get_ctx(tline->text, FALSE);
2734 if (!ctx)
2735 smhead = &smacros[hash(tline->text)];
2736 else
2737 smhead = &ctx->localmac;
2739 mname = tline->text;
2740 last = tline;
2741 last->next = NULL;
2744 * We now have a macro name... go hunt for it.
2746 while (smacro_defined(ctx, mname, -1, &smac, 1))
2748 /* Defined, so we need to find its predecessor and nuke it */
2749 SMacro **s;
2750 for (s = smhead; *s && *s != smac; s = &(*s)->next);
2751 if (*s)
2753 *s = smac->next;
2754 nasm_free(smac->name);
2755 free_tlist(smac->expansion);
2756 nasm_free(smac);
2759 free_tlist(origline);
2760 return DIRECTIVE_FOUND;
2762 case PP_STRLEN:
2763 tline = tline->next;
2764 skip_white_(tline);
2765 tline = expand_id(tline);
2766 if (!tline || (tline->type != TOK_ID &&
2767 (tline->type != TOK_PREPROC_ID ||
2768 tline->text[1] != '$')))
2770 error(ERR_NONFATAL,
2771 "`%%strlen' expects a macro identifier as first parameter");
2772 free_tlist(origline);
2773 return DIRECTIVE_FOUND;
2775 ctx = get_ctx(tline->text, FALSE);
2776 if (!ctx)
2777 smhead = &smacros[hash(tline->text)];
2778 else
2779 smhead = &ctx->localmac;
2780 mname = tline->text;
2781 last = tline;
2782 tline = expand_smacro(tline->next);
2783 last->next = NULL;
2785 t = tline;
2786 while (tok_type_(t, TOK_WHITESPACE))
2787 t = t->next;
2788 /* t should now point to the string */
2789 if (t->type != TOK_STRING)
2791 error(ERR_NONFATAL,
2792 "`%%strlen` requires string as second parameter");
2793 free_tlist(tline);
2794 free_tlist(origline);
2795 return DIRECTIVE_FOUND;
2798 macro_start = nasm_malloc(sizeof(*macro_start));
2799 macro_start->next = NULL;
2800 make_tok_num(macro_start, strlen(t->text) - 2);
2801 macro_start->mac = NULL;
2804 * We now have a macro name, an implicit parameter count of
2805 * zero, and a numeric token to use as an expansion. Create
2806 * and store an SMacro.
2808 if (smacro_defined(ctx, mname, 0, &smac, i == PP_STRLEN))
2810 if (!smac)
2811 error(ERR_WARNING,
2812 "single-line macro `%s' defined both with and"
2813 " without parameters", mname);
2814 else
2817 * We're redefining, so we have to take over an
2818 * existing SMacro structure. This means freeing
2819 * what was already in it.
2821 nasm_free(smac->name);
2822 free_tlist(smac->expansion);
2825 else
2827 smac = nasm_malloc(sizeof(SMacro));
2828 smac->next = *smhead;
2829 *smhead = smac;
2831 smac->name = nasm_strdup(mname);
2832 smac->casesense = (i == PP_STRLEN);
2833 smac->nparam = 0;
2834 smac->expansion = macro_start;
2835 smac->in_progress = FALSE;
2836 free_tlist(tline);
2837 free_tlist(origline);
2838 return DIRECTIVE_FOUND;
2840 case PP_SUBSTR:
2841 tline = tline->next;
2842 skip_white_(tline);
2843 tline = expand_id(tline);
2844 if (!tline || (tline->type != TOK_ID &&
2845 (tline->type != TOK_PREPROC_ID ||
2846 tline->text[1] != '$')))
2848 error(ERR_NONFATAL,
2849 "`%%substr' expects a macro identifier as first parameter");
2850 free_tlist(origline);
2851 return DIRECTIVE_FOUND;
2853 ctx = get_ctx(tline->text, FALSE);
2854 if (!ctx)
2855 smhead = &smacros[hash(tline->text)];
2856 else
2857 smhead = &ctx->localmac;
2858 mname = tline->text;
2859 last = tline;
2860 tline = expand_smacro(tline->next);
2861 last->next = NULL;
2863 t = tline->next;
2864 while (tok_type_(t, TOK_WHITESPACE))
2865 t = t->next;
2867 /* t should now point to the string */
2868 if (t->type != TOK_STRING)
2870 error(ERR_NONFATAL,
2871 "`%%substr` requires string as second parameter");
2872 free_tlist(tline);
2873 free_tlist(origline);
2874 return DIRECTIVE_FOUND;
2877 tt = t->next;
2878 tptr = &tt;
2879 tokval.t_type = TOKEN_INVALID;
2880 evalresult =
2881 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2882 if (!evalresult)
2884 free_tlist(tline);
2885 free_tlist(origline);
2886 return DIRECTIVE_FOUND;
2888 if (!is_simple(evalresult))
2890 error(ERR_NONFATAL, "non-constant value given to `%%substr`");
2891 free_tlist(tline);
2892 free_tlist(origline);
2893 return DIRECTIVE_FOUND;
2896 macro_start = nasm_malloc(sizeof(*macro_start));
2897 macro_start->next = NULL;
2898 macro_start->text = nasm_strdup("'''");
2899 if (evalresult->value > 0
2900 && evalresult->value < strlen(t->text) - 1)
2902 macro_start->text[1] = t->text[evalresult->value];
2904 else
2906 macro_start->text[2] = '\0';
2908 macro_start->type = TOK_STRING;
2909 macro_start->mac = NULL;
2912 * We now have a macro name, an implicit parameter count of
2913 * zero, and a numeric token to use as an expansion. Create
2914 * and store an SMacro.
2916 if (smacro_defined(ctx, mname, 0, &smac, i == PP_SUBSTR))
2918 if (!smac)
2919 error(ERR_WARNING,
2920 "single-line macro `%s' defined both with and"
2921 " without parameters", mname);
2922 else
2925 * We're redefining, so we have to take over an
2926 * existing SMacro structure. This means freeing
2927 * what was already in it.
2929 nasm_free(smac->name);
2930 free_tlist(smac->expansion);
2933 else
2935 smac = nasm_malloc(sizeof(SMacro));
2936 smac->next = *smhead;
2937 *smhead = smac;
2939 smac->name = nasm_strdup(mname);
2940 smac->casesense = (i == PP_SUBSTR);
2941 smac->nparam = 0;
2942 smac->expansion = macro_start;
2943 smac->in_progress = FALSE;
2944 free_tlist(tline);
2945 free_tlist(origline);
2946 return DIRECTIVE_FOUND;
2949 case PP_ASSIGN:
2950 case PP_IASSIGN:
2951 tline = tline->next;
2952 skip_white_(tline);
2953 tline = expand_id(tline);
2954 if (!tline || (tline->type != TOK_ID &&
2955 (tline->type != TOK_PREPROC_ID ||
2956 tline->text[1] != '$')))
2958 error(ERR_NONFATAL,
2959 "`%%%sassign' expects a macro identifier",
2960 (i == PP_IASSIGN ? "i" : ""));
2961 free_tlist(origline);
2962 return DIRECTIVE_FOUND;
2964 ctx = get_ctx(tline->text, FALSE);
2965 if (!ctx)
2966 smhead = &smacros[hash(tline->text)];
2967 else
2968 smhead = &ctx->localmac;
2969 mname = tline->text;
2970 last = tline;
2971 tline = expand_smacro(tline->next);
2972 last->next = NULL;
2974 t = tline;
2975 tptr = &t;
2976 tokval.t_type = TOKEN_INVALID;
2977 evalresult =
2978 evaluate(ppscan, tptr, &tokval, NULL, pass, error, NULL);
2979 free_tlist(tline);
2980 if (!evalresult)
2982 free_tlist(origline);
2983 return DIRECTIVE_FOUND;
2986 if (tokval.t_type)
2987 error(ERR_WARNING,
2988 "trailing garbage after expression ignored");
2990 if (!is_simple(evalresult))
2992 error(ERR_NONFATAL,
2993 "non-constant value given to `%%%sassign'",
2994 (i == PP_IASSIGN ? "i" : ""));
2995 free_tlist(origline);
2996 return DIRECTIVE_FOUND;
2999 macro_start = nasm_malloc(sizeof(*macro_start));
3000 macro_start->next = NULL;
3001 make_tok_num(macro_start, reloc_value(evalresult));
3002 macro_start->mac = NULL;
3005 * We now have a macro name, an implicit parameter count of
3006 * zero, and a numeric token to use as an expansion. Create
3007 * and store an SMacro.
3009 if (smacro_defined(ctx, mname, 0, &smac, i == PP_ASSIGN))
3011 if (!smac)
3012 error(ERR_WARNING,
3013 "single-line macro `%s' defined both with and"
3014 " without parameters", mname);
3015 else
3018 * We're redefining, so we have to take over an
3019 * existing SMacro structure. This means freeing
3020 * what was already in it.
3022 nasm_free(smac->name);
3023 free_tlist(smac->expansion);
3026 else
3028 smac = nasm_malloc(sizeof(SMacro));
3029 smac->next = *smhead;
3030 *smhead = smac;
3032 smac->name = nasm_strdup(mname);
3033 smac->casesense = (i == PP_ASSIGN);
3034 smac->nparam = 0;
3035 smac->expansion = macro_start;
3036 smac->in_progress = FALSE;
3037 free_tlist(origline);
3038 return DIRECTIVE_FOUND;
3040 case PP_LINE:
3042 * Syntax is `%line nnn[+mmm] [filename]'
3044 tline = tline->next;
3045 skip_white_(tline);
3046 if (!tok_type_(tline, TOK_NUMBER))
3048 error(ERR_NONFATAL, "`%%line' expects line number");
3049 free_tlist(origline);
3050 return DIRECTIVE_FOUND;
3052 k = readnum(tline->text, &j);
3053 m = 1;
3054 tline = tline->next;
3055 if (tok_is_(tline, "+"))
3057 tline = tline->next;
3058 if (!tok_type_(tline, TOK_NUMBER))
3060 error(ERR_NONFATAL, "`%%line' expects line increment");
3061 free_tlist(origline);
3062 return DIRECTIVE_FOUND;
3064 m = readnum(tline->text, &j);
3065 tline = tline->next;
3067 skip_white_(tline);
3068 src_set_linnum(k);
3069 istk->lineinc = m;
3070 if (tline)
3072 nasm_free(src_set_fname(detoken(tline, FALSE)));
3074 free_tlist(origline);
3075 return DIRECTIVE_FOUND;
3077 default:
3078 error(ERR_FATAL,
3079 "preprocessor directive `%s' not yet implemented",
3080 directives[i]);
3081 break;
3083 return DIRECTIVE_FOUND;
3087 * Ensure that a macro parameter contains a condition code and
3088 * nothing else. Return the condition code index if so, or -1
3089 * otherwise.
3091 static int
3092 find_cc(Token * t)
3094 Token *tt;
3095 int i, j, k, m;
3097 skip_white_(t);
3098 if (t->type != TOK_ID)
3099 return -1;
3100 tt = t->next;
3101 skip_white_(tt);
3102 if (tt && (tt->type != TOK_OTHER || strcmp(tt->text, ",")))
3103 return -1;
3105 i = -1;
3106 j = elements(conditions);
3107 while (j - i > 1)
3109 k = (j + i) / 2;
3110 m = nasm_stricmp(t->text, conditions[k]);
3111 if (m == 0)
3113 i = k;
3114 j = -2;
3115 break;
3117 else if (m < 0)
3119 j = k;
3121 else
3122 i = k;
3124 if (j != -2)
3125 return -1;
3126 return i;
3130 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3131 * %-n) and MMacro-local identifiers (%%foo).
3133 static Token *
3134 expand_mmac_params(Token * tline)
3136 Token *t, *tt, **tail, *thead;
3138 tail = &thead;
3139 thead = NULL;
3141 while (tline)
3143 if (tline->type == TOK_PREPROC_ID &&
3144 (((tline->text[1] == '+' || tline->text[1] == '-')
3145 && tline->text[2]) || tline->text[1] == '%'
3146 || (tline->text[1] >= '0' && tline->text[1] <= '9')))
3148 char *text = NULL;
3149 int type = 0, cc; /* type = 0 to placate optimisers */
3150 char tmpbuf[30];
3151 int n, i;
3152 MMacro *mac;
3154 t = tline;
3155 tline = tline->next;
3157 mac = istk->mstk;
3158 while (mac && !mac->name) /* avoid mistaking %reps for macros */
3159 mac = mac->next_active;
3160 if (!mac)
3161 error(ERR_NONFATAL, "`%s': not in a macro call", t->text);
3162 else
3163 switch (t->text[1])
3166 * We have to make a substitution of one of the
3167 * forms %1, %-1, %+1, %%foo, %0.
3169 case '0':
3170 type = TOK_NUMBER;
3171 sprintf(tmpbuf, "%d", mac->nparam);
3172 text = nasm_strdup(tmpbuf);
3173 break;
3174 case '%':
3175 type = TOK_ID;
3176 sprintf(tmpbuf, "..@%lu.", mac->unique);
3177 text = nasm_strcat(tmpbuf, t->text + 2);
3178 break;
3179 case '-':
3180 n = atoi(t->text + 2) - 1;
3181 if (n >= mac->nparam)
3182 tt = NULL;
3183 else
3185 if (mac->nparam > 1)
3186 n = (n + mac->rotate) % mac->nparam;
3187 tt = mac->params[n];
3189 cc = find_cc(tt);
3190 if (cc == -1)
3192 error(ERR_NONFATAL,
3193 "macro parameter %d is not a condition code",
3194 n + 1);
3195 text = NULL;
3197 else
3199 type = TOK_ID;
3200 if (inverse_ccs[cc] == -1)
3202 error(ERR_NONFATAL,
3203 "condition code `%s' is not invertible",
3204 conditions[cc]);
3205 text = NULL;
3207 else
3208 text =
3209 nasm_strdup(conditions[inverse_ccs
3210 [cc]]);
3212 break;
3213 case '+':
3214 n = atoi(t->text + 2) - 1;
3215 if (n >= mac->nparam)
3216 tt = NULL;
3217 else
3219 if (mac->nparam > 1)
3220 n = (n + mac->rotate) % mac->nparam;
3221 tt = mac->params[n];
3223 cc = find_cc(tt);
3224 if (cc == -1)
3226 error(ERR_NONFATAL,
3227 "macro parameter %d is not a condition code",
3228 n + 1);
3229 text = NULL;
3231 else
3233 type = TOK_ID;
3234 text = nasm_strdup(conditions[cc]);
3236 break;
3237 default:
3238 n = atoi(t->text + 1) - 1;
3239 if (n >= mac->nparam)
3240 tt = NULL;
3241 else
3243 if (mac->nparam > 1)
3244 n = (n + mac->rotate) % mac->nparam;
3245 tt = mac->params[n];
3247 if (tt)
3249 for (i = 0; i < mac->paramlen[n]; i++)
3251 *tail =
3252 new_Token(NULL, tt->type, tt->text,
3254 tail = &(*tail)->next;
3255 tt = tt->next;
3258 text = NULL; /* we've done it here */
3259 break;
3261 if (!text)
3263 delete_Token(t);
3265 else
3267 *tail = t;
3268 tail = &t->next;
3269 t->type = type;
3270 nasm_free(t->text);
3271 t->text = text;
3272 t->mac = NULL;
3274 continue;
3276 else
3278 t = *tail = tline;
3279 tline = tline->next;
3280 t->mac = NULL;
3281 tail = &t->next;
3284 *tail = NULL;
3285 t = thead;
3286 for (; t && (tt = t->next) != NULL; t = t->next)
3287 switch (t->type)
3289 case TOK_WHITESPACE:
3290 if (tt->type == TOK_WHITESPACE)
3292 t->next = delete_Token(tt);
3294 break;
3295 case TOK_ID:
3296 if (tt->type == TOK_ID || 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;
3304 case TOK_NUMBER:
3305 if (tt->type == TOK_NUMBER)
3307 char *tmp = nasm_strcat(t->text, tt->text);
3308 nasm_free(t->text);
3309 t->text = tmp;
3310 t->next = delete_Token(tt);
3312 break;
3315 return thead;
3319 * Expand all single-line macro calls made in the given line.
3320 * Return the expanded version of the line. The original is deemed
3321 * to be destroyed in the process. (In reality we'll just move
3322 * Tokens from input to output a lot of the time, rather than
3323 * actually bothering to destroy and replicate.)
3325 static Token *
3326 expand_smacro(Token * tline)
3328 Token *t, *tt, *mstart, **tail, *thead;
3329 SMacro *head = NULL, *m;
3330 Token **params;
3331 int *paramsize;
3332 int nparam, sparam, brackets, rescan;
3333 Token *org_tline = tline;
3334 Context *ctx;
3335 char *mname;
3338 * Trick: we should avoid changing the start token pointer since it can
3339 * be contained in "next" field of other token. Because of this
3340 * we allocate a copy of first token and work with it; at the end of
3341 * routine we copy it back
3343 if (org_tline)
3345 tline =
3346 new_Token(org_tline->next, org_tline->type, org_tline->text,
3348 tline->mac = org_tline->mac;
3349 nasm_free(org_tline->text);
3350 org_tline->text = NULL;
3353 again:
3354 tail = &thead;
3355 thead = NULL;
3357 while (tline)
3358 { /* main token loop */
3359 if ((mname = tline->text))
3361 /* if this token is a local macro, look in local context */
3362 if (tline->type == TOK_ID || tline->type == TOK_PREPROC_ID)
3363 ctx = get_ctx(mname, TRUE);
3364 else
3365 ctx = NULL;
3366 if (!ctx)
3367 head = smacros[hash(mname)];
3368 else
3369 head = ctx->localmac;
3371 * We've hit an identifier. As in is_mmacro below, we first
3372 * check whether the identifier is a single-line macro at
3373 * all, then think about checking for parameters if
3374 * necessary.
3376 for (m = head; m; m = m->next)
3377 if (!mstrcmp(m->name, mname, m->casesense))
3378 break;
3379 if (m)
3381 mstart = tline;
3382 params = NULL;
3383 paramsize = NULL;
3384 if (m->nparam == 0)
3387 * Simple case: the macro is parameterless. Discard the
3388 * one token that the macro call took, and push the
3389 * expansion back on the to-do stack.
3391 if (!m->expansion)
3393 if (!strcmp("__FILE__", m->name))
3395 long num = 0;
3396 src_get(&num, &(tline->text));
3397 nasm_quote(&(tline->text));
3398 tline->type = TOK_STRING;
3399 continue;
3401 if (!strcmp("__LINE__", m->name))
3403 nasm_free(tline->text);
3404 make_tok_num(tline, src_get_linnum());
3405 continue;
3407 tline = delete_Token(tline);
3408 continue;
3411 else
3414 * Complicated case: at least one macro with this name
3415 * exists and takes parameters. We must find the
3416 * parameters in the call, count them, find the SMacro
3417 * that corresponds to that form of the macro call, and
3418 * substitute for the parameters when we expand. What a
3419 * pain.
3421 tline = tline->next;
3422 skip_white_(tline);
3423 if (!tok_is_(tline, "("))
3426 * This macro wasn't called with parameters: ignore
3427 * the call. (Behaviour borrowed from gnu cpp.)
3429 tline = mstart;
3430 m = NULL;
3432 else
3434 int paren = 0;
3435 int white = 0;
3436 brackets = 0;
3437 nparam = 0;
3438 tline = tline->next;
3439 sparam = PARAM_DELTA;
3440 params = nasm_malloc(sparam * sizeof(Token *));
3441 params[0] = tline;
3442 paramsize = nasm_malloc(sparam * sizeof(int));
3443 paramsize[0] = 0;
3444 for (;; tline = tline->next)
3445 { /* parameter loop */
3446 if (!tline)
3448 error(ERR_NONFATAL,
3449 "macro call expects terminating `)'");
3450 break;
3452 if (tline->type == TOK_WHITESPACE
3453 && brackets <= 0)
3455 if (paramsize[nparam])
3456 white++;
3457 else
3458 params[nparam] = tline->next;
3459 continue; /* parameter loop */
3461 if (tline->type == TOK_OTHER
3462 && tline->text[1] == 0)
3464 char ch = tline->text[0];
3465 if (ch == ',' && !paren && brackets <= 0)
3467 if (++nparam >= sparam)
3469 sparam += PARAM_DELTA;
3470 params = nasm_realloc(params,
3471 sparam * sizeof(Token *));
3472 paramsize = nasm_realloc(paramsize,
3473 sparam * sizeof(int));
3475 params[nparam] = tline->next;
3476 paramsize[nparam] = 0;
3477 white = 0;
3478 continue; /* parameter loop */
3480 if (ch == '{' &&
3481 (brackets > 0 || (brackets == 0 &&
3482 !paramsize[nparam])))
3484 if (!(brackets++))
3486 params[nparam] = tline->next;
3487 continue; /* parameter loop */
3490 if (ch == '}' && brackets > 0)
3491 if (--brackets == 0)
3493 brackets = -1;
3494 continue; /* parameter loop */
3496 if (ch == '(' && !brackets)
3497 paren++;
3498 if (ch == ')' && brackets <= 0)
3499 if (--paren < 0)
3500 break;
3502 if (brackets < 0)
3504 brackets = 0;
3505 error(ERR_NONFATAL, "braces do not "
3506 "enclose all of macro parameter");
3508 paramsize[nparam] += white + 1;
3509 white = 0;
3510 } /* parameter loop */
3511 nparam++;
3512 while (m && (m->nparam != nparam ||
3513 mstrcmp(m->name, mname,
3514 m->casesense)))
3515 m = m->next;
3516 if (!m)
3517 error(ERR_WARNING | ERR_WARN_MNP,
3518 "macro `%s' exists, "
3519 "but not taking %d parameters",
3520 mstart->text, nparam);
3523 if (m && m->in_progress)
3524 m = NULL;
3525 if (!m) /* in progess or didn't find '(' or wrong nparam */
3528 * Design question: should we handle !tline, which
3529 * indicates missing ')' here, or expand those
3530 * macros anyway, which requires the (t) test a few
3531 * lines down?
3533 nasm_free(params);
3534 nasm_free(paramsize);
3535 tline = mstart;
3537 else
3540 * Expand the macro: we are placed on the last token of the
3541 * call, so that we can easily split the call from the
3542 * following tokens. We also start by pushing an SMAC_END
3543 * token for the cycle removal.
3545 t = tline;
3546 if (t)
3548 tline = t->next;
3549 t->next = NULL;
3551 tt = new_Token(tline, TOK_SMAC_END, NULL, 0);
3552 tt->mac = m;
3553 m->in_progress = TRUE;
3554 tline = tt;
3555 for (t = m->expansion; t; t = t->next)
3557 if (t->type >= TOK_SMAC_PARAM)
3559 Token *pcopy = tline, **ptail = &pcopy;
3560 Token *ttt, *pt;
3561 int i;
3563 ttt = params[t->type - TOK_SMAC_PARAM];
3564 for (i = paramsize[t->type - TOK_SMAC_PARAM];
3565 --i >= 0;)
3567 pt = *ptail =
3568 new_Token(tline, ttt->type, ttt->text,
3570 ptail = &pt->next;
3571 ttt = ttt->next;
3573 tline = pcopy;
3575 else
3577 tt = new_Token(tline, t->type, t->text, 0);
3578 tline = tt;
3583 * Having done that, get rid of the macro call, and clean
3584 * up the parameters.
3586 nasm_free(params);
3587 nasm_free(paramsize);
3588 free_tlist(mstart);
3589 continue; /* main token loop */
3594 if (tline->type == TOK_SMAC_END)
3596 tline->mac->in_progress = FALSE;
3597 tline = delete_Token(tline);
3599 else
3601 t = *tail = tline;
3602 tline = tline->next;
3603 t->mac = NULL;
3604 t->next = NULL;
3605 tail = &t->next;
3610 * Now scan the entire line and look for successive TOK_IDs that resulted
3611 * after expansion (they can't be produced by tokenise()). The successive
3612 * TOK_IDs should be concatenated.
3613 * Also we look for %+ tokens and concatenate the tokens before and after
3614 * them (without white spaces in between).
3616 t = thead;
3617 rescan = 0;
3618 while (t)
3620 while (t && t->type != TOK_ID && t->type != TOK_PREPROC_ID)
3621 t = t->next;
3622 if (!t || !t->next)
3623 break;
3624 if (t->next->type == TOK_ID ||
3625 t->next->type == TOK_PREPROC_ID ||
3626 t->next->type == TOK_NUMBER)
3628 char *p = nasm_strcat(t->text, t->next->text);
3629 nasm_free(t->text);
3630 t->next = delete_Token(t->next);
3631 t->text = p;
3632 rescan = 1;
3634 else if (t->next->type == TOK_WHITESPACE && t->next->next &&
3635 t->next->next->type == TOK_PREPROC_ID &&
3636 strcmp(t->next->next->text, "%+") == 0)
3638 /* free the next whitespace, the %+ token and next whitespace */
3639 int i;
3640 for (i = 1; i <= 3; i++)
3642 if (!t->next || (i != 2 && t->next->type != TOK_WHITESPACE))
3643 break;
3644 t->next = delete_Token(t->next);
3645 } /* endfor */
3647 else
3648 t = t->next;
3650 /* If we concatenaded something, re-scan the line for macros */
3651 if (rescan)
3653 tline = thead;
3654 goto again;
3657 if (org_tline)
3659 if (thead)
3661 *org_tline = *thead;
3662 /* since we just gave text to org_line, don't free it */
3663 thead->text = NULL;
3664 delete_Token(thead);
3666 else
3668 /* the expression expanded to empty line;
3669 we can't return NULL for some reasons
3670 we just set the line to a single WHITESPACE token. */
3671 memset(org_tline, 0, sizeof(*org_tline));
3672 org_tline->text = NULL;
3673 org_tline->type = TOK_WHITESPACE;
3675 thead = org_tline;
3678 return thead;
3682 * Similar to expand_smacro but used exclusively with macro identifiers
3683 * right before they are fetched in. The reason is that there can be
3684 * identifiers consisting of several subparts. We consider that if there
3685 * are more than one element forming the name, user wants a expansion,
3686 * otherwise it will be left as-is. Example:
3688 * %define %$abc cde
3690 * the identifier %$abc will be left as-is so that the handler for %define
3691 * will suck it and define the corresponding value. Other case:
3693 * %define _%$abc cde
3695 * In this case user wants name to be expanded *before* %define starts
3696 * working, so we'll expand %$abc into something (if it has a value;
3697 * otherwise it will be left as-is) then concatenate all successive
3698 * PP_IDs into one.
3700 static Token *
3701 expand_id(Token * tline)
3703 Token *cur, *oldnext = NULL;
3705 if (!tline || !tline->next)
3706 return tline;
3708 cur = tline;
3709 while (cur->next &&
3710 (cur->next->type == TOK_ID ||
3711 cur->next->type == TOK_PREPROC_ID || cur->next->type == TOK_NUMBER))
3712 cur = cur->next;
3714 /* If identifier consists of just one token, don't expand */
3715 if (cur == tline)
3716 return tline;
3718 if (cur)
3720 oldnext = cur->next; /* Detach the tail past identifier */
3721 cur->next = NULL; /* so that expand_smacro stops here */
3724 tline = expand_smacro(tline);
3726 if (cur)
3728 /* expand_smacro possibly changhed tline; re-scan for EOL */
3729 cur = tline;
3730 while (cur && cur->next)
3731 cur = cur->next;
3732 if (cur)
3733 cur->next = oldnext;
3736 return tline;
3740 * Determine whether the given line constitutes a multi-line macro
3741 * call, and return the MMacro structure called if so. Doesn't have
3742 * to check for an initial label - that's taken care of in
3743 * expand_mmacro - but must check numbers of parameters. Guaranteed
3744 * to be called with tline->type == TOK_ID, so the putative macro
3745 * name is easy to find.
3747 static MMacro *
3748 is_mmacro(Token * tline, Token *** params_array)
3750 MMacro *head, *m;
3751 Token **params;
3752 int nparam;
3754 head = mmacros[hash(tline->text)];
3757 * Efficiency: first we see if any macro exists with the given
3758 * name. If not, we can return NULL immediately. _Then_ we
3759 * count the parameters, and then we look further along the
3760 * list if necessary to find the proper MMacro.
3762 for (m = head; m; m = m->next)
3763 if (!mstrcmp(m->name, tline->text, m->casesense))
3764 break;
3765 if (!m)
3766 return NULL;
3769 * OK, we have a potential macro. Count and demarcate the
3770 * parameters.
3772 count_mmac_params(tline->next, &nparam, &params);
3775 * So we know how many parameters we've got. Find the MMacro
3776 * structure that handles this number.
3778 while (m)
3780 if (m->nparam_min <= nparam && (m->plus || nparam <= m->nparam_max))
3783 * This one is right. Just check if cycle removal
3784 * prohibits us using it before we actually celebrate...
3786 if (m->in_progress)
3788 #if 0
3789 error(ERR_NONFATAL,
3790 "self-reference in multi-line macro `%s'", m->name);
3791 #endif
3792 nasm_free(params);
3793 return NULL;
3796 * It's right, and we can use it. Add its default
3797 * parameters to the end of our list if necessary.
3799 if (m->defaults && nparam < m->nparam_min + m->ndefs)
3801 params =
3802 nasm_realloc(params,
3803 ((m->nparam_min + m->ndefs + 1) * sizeof(*params)));
3804 while (nparam < m->nparam_min + m->ndefs)
3806 params[nparam] = m->defaults[nparam - m->nparam_min];
3807 nparam++;
3811 * If we've gone over the maximum parameter count (and
3812 * we're in Plus mode), ignore parameters beyond
3813 * nparam_max.
3815 if (m->plus && nparam > m->nparam_max)
3816 nparam = m->nparam_max;
3818 * Then terminate the parameter list, and leave.
3820 if (!params)
3821 { /* need this special case */
3822 params = nasm_malloc(sizeof(*params));
3823 nparam = 0;
3825 params[nparam] = NULL;
3826 *params_array = params;
3827 return m;
3830 * This one wasn't right: look for the next one with the
3831 * same name.
3833 for (m = m->next; m; m = m->next)
3834 if (!mstrcmp(m->name, tline->text, m->casesense))
3835 break;
3839 * After all that, we didn't find one with the right number of
3840 * parameters. Issue a warning, and fail to expand the macro.
3842 error(ERR_WARNING | ERR_WARN_MNP,
3843 "macro `%s' exists, but not taking %d parameters",
3844 tline->text, nparam);
3845 nasm_free(params);
3846 return NULL;
3850 * Expand the multi-line macro call made by the given line, if
3851 * there is one to be expanded. If there is, push the expansion on
3852 * istk->expansion and return 1. Otherwise return 0.
3854 static int
3855 expand_mmacro(Token * tline)
3857 Token *startline = tline;
3858 Token *label = NULL;
3859 int dont_prepend = 0;
3860 Token **params, *t, *tt;
3861 MMacro *m;
3862 Line *l, *ll;
3863 int i, nparam, *paramlen;
3865 t = tline;
3866 skip_white_(t);
3867 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
3868 if (!tok_type_(t, TOK_ID) && !tok_type_(t, TOK_PREPROC_ID))
3869 return 0;
3870 m = is_mmacro(t, &params);
3871 if (!m)
3873 Token *last;
3875 * We have an id which isn't a macro call. We'll assume
3876 * it might be a label; we'll also check to see if a
3877 * colon follows it. Then, if there's another id after
3878 * that lot, we'll check it again for macro-hood.
3880 label = last = t;
3881 t = t->next;
3882 if (tok_type_(t, TOK_WHITESPACE))
3883 last = t, t = t->next;
3884 if (tok_is_(t, ":"))
3886 dont_prepend = 1;
3887 last = t, t = t->next;
3888 if (tok_type_(t, TOK_WHITESPACE))
3889 last = t, t = t->next;
3891 if (!tok_type_(t, TOK_ID) || (m = is_mmacro(t, &params)) == NULL)
3892 return 0;
3893 last->next = NULL;
3894 tline = t;
3898 * Fix up the parameters: this involves stripping leading and
3899 * trailing whitespace, then stripping braces if they are
3900 * present.
3902 for (nparam = 0; params[nparam]; nparam++)
3904 paramlen = nparam ? nasm_malloc(nparam * sizeof(*paramlen)) : NULL;
3906 for (i = 0; params[i]; i++)
3908 int brace = FALSE;
3909 int comma = (!m->plus || i < nparam - 1);
3911 t = params[i];
3912 skip_white_(t);
3913 if (tok_is_(t, "{"))
3914 t = t->next, brace = TRUE, comma = FALSE;
3915 params[i] = t;
3916 paramlen[i] = 0;
3917 while (t)
3919 if (comma && t->type == TOK_OTHER && !strcmp(t->text, ","))
3920 break; /* ... because we have hit a comma */
3921 if (comma && t->type == TOK_WHITESPACE && tok_is_(t->next, ","))
3922 break; /* ... or a space then a comma */
3923 if (brace && t->type == TOK_OTHER && !strcmp(t->text, "}"))
3924 break; /* ... or a brace */
3925 t = t->next;
3926 paramlen[i]++;
3931 * OK, we have a MMacro structure together with a set of
3932 * parameters. We must now go through the expansion and push
3933 * copies of each Line on to istk->expansion. Substitution of
3934 * parameter tokens and macro-local tokens doesn't get done
3935 * until the single-line macro substitution process; this is
3936 * because delaying them allows us to change the semantics
3937 * later through %rotate.
3939 * First, push an end marker on to istk->expansion, mark this
3940 * macro as in progress, and set up its invocation-specific
3941 * variables.
3943 ll = nasm_malloc(sizeof(Line));
3944 ll->next = istk->expansion;
3945 ll->finishes = m;
3946 ll->first = NULL;
3947 istk->expansion = ll;
3949 m->in_progress = TRUE;
3950 m->params = params;
3951 m->iline = tline;
3952 m->nparam = nparam;
3953 m->rotate = 0;
3954 m->paramlen = paramlen;
3955 m->unique = unique++;
3956 m->lineno = 0;
3958 m->next_active = istk->mstk;
3959 istk->mstk = m;
3961 for (l = m->expansion; l; l = l->next)
3963 Token **tail;
3965 ll = nasm_malloc(sizeof(Line));
3966 ll->finishes = NULL;
3967 ll->next = istk->expansion;
3968 istk->expansion = ll;
3969 tail = &ll->first;
3971 for (t = l->first; t; t = t->next)
3973 Token *x = t;
3974 if (t->type == TOK_PREPROC_ID &&
3975 t->text[1] == '0' && t->text[2] == '0')
3977 dont_prepend = -1;
3978 x = label;
3979 if (!x)
3980 continue;
3982 tt = *tail = new_Token(NULL, x->type, x->text, 0);
3983 tail = &tt->next;
3985 *tail = NULL;
3989 * If we had a label, push it on as the first line of
3990 * the macro expansion.
3992 if (label)
3994 if (dont_prepend < 0)
3995 free_tlist(startline);
3996 else
3998 ll = nasm_malloc(sizeof(Line));
3999 ll->finishes = NULL;
4000 ll->next = istk->expansion;
4001 istk->expansion = ll;
4002 ll->first = startline;
4003 if (!dont_prepend)
4005 while (label->next)
4006 label = label->next;
4007 label->next = tt = new_Token(NULL, TOK_OTHER, ":", 0);
4012 list->uplevel(m->nolist ? LIST_MACRO_NOLIST : LIST_MACRO);
4014 return 1;
4018 * Since preprocessor always operate only on the line that didn't
4019 * arrived yet, we should always use ERR_OFFBY1. Also since user
4020 * won't want to see same error twice (preprocessing is done once
4021 * per pass) we will want to show errors only during pass one.
4023 static void
4024 error(int severity, const char *fmt, ...)
4026 va_list arg;
4027 char buff[1024];
4029 /* If we're in a dead branch of IF or something like it, ignore the error */
4030 if (istk && istk->conds && !emitting(istk->conds->state))
4031 return;
4033 va_start(arg, fmt);
4034 vsprintf(buff, fmt, arg);
4035 va_end(arg);
4037 if (istk && istk->mstk && istk->mstk->name)
4038 _error(severity | ERR_PASS1, "(%s:%d) %s", istk->mstk->name,
4039 istk->mstk->lineno, buff);
4040 else
4041 _error(severity | ERR_PASS1, "%s", buff);
4044 static void
4045 pp_reset(char *file, int apass, efunc errfunc, evalfunc eval,
4046 ListGen * listgen)
4048 int h;
4050 _error = errfunc;
4051 cstk = NULL;
4052 istk = nasm_malloc(sizeof(Include));
4053 istk->next = NULL;
4054 istk->conds = NULL;
4055 istk->expansion = NULL;
4056 istk->mstk = NULL;
4057 istk->fp = fopen(file, "r");
4058 istk->fname = NULL;
4059 src_set_fname(nasm_strdup(file));
4060 src_set_linnum(0);
4061 istk->lineinc = 1;
4062 if (!istk->fp)
4063 error(ERR_FATAL | ERR_NOFILE, "unable to open input file `%s'", file);
4064 defining = NULL;
4065 for (h = 0; h < NHASH; h++)
4067 mmacros[h] = NULL;
4068 smacros[h] = NULL;
4070 unique = 0;
4071 if (tasm_compatible_mode) {
4072 stdmacpos = stdmac;
4073 } else {
4074 stdmacpos = &stdmac[TASM_MACRO_COUNT];
4076 any_extrastdmac = (extrastdmac != NULL);
4077 list = listgen;
4078 evaluate = eval;
4079 pass = apass;
4082 static char *
4083 pp_getline(void)
4085 char *line;
4086 Token *tline;
4088 while (1)
4091 * Fetch a tokenised line, either from the macro-expansion
4092 * buffer or from the input file.
4094 tline = NULL;
4095 while (istk->expansion && istk->expansion->finishes)
4097 Line *l = istk->expansion;
4098 if (!l->finishes->name && l->finishes->in_progress > 1)
4100 Line *ll;
4103 * This is a macro-end marker for a macro with no
4104 * name, which means it's not really a macro at all
4105 * but a %rep block, and the `in_progress' field is
4106 * more than 1, meaning that we still need to
4107 * repeat. (1 means the natural last repetition; 0
4108 * means termination by %exitrep.) We have
4109 * therefore expanded up to the %endrep, and must
4110 * push the whole block on to the expansion buffer
4111 * again. We don't bother to remove the macro-end
4112 * marker: we'd only have to generate another one
4113 * if we did.
4115 l->finishes->in_progress--;
4116 for (l = l->finishes->expansion; l; l = l->next)
4118 Token *t, *tt, **tail;
4120 ll = nasm_malloc(sizeof(Line));
4121 ll->next = istk->expansion;
4122 ll->finishes = NULL;
4123 ll->first = NULL;
4124 tail = &ll->first;
4126 for (t = l->first; t; t = t->next)
4128 if (t->text || t->type == TOK_WHITESPACE)
4130 tt = *tail = new_Token(NULL, t->type, t->text, 0);
4131 tail = &tt->next;
4135 istk->expansion = ll;
4138 else
4141 * Check whether a `%rep' was started and not ended
4142 * within this macro expansion. This can happen and
4143 * should be detected. It's a fatal error because
4144 * I'm too confused to work out how to recover
4145 * sensibly from it.
4147 if (defining)
4149 if (defining->name)
4150 error(ERR_PANIC, "defining with name in expansion");
4151 else if (istk->mstk->name)
4152 error(ERR_FATAL, "`%%rep' without `%%endrep' within"
4153 " expansion of macro `%s'", istk->mstk->name);
4157 * FIXME: investigate the relationship at this point between
4158 * istk->mstk and l->finishes
4161 MMacro *m = istk->mstk;
4162 istk->mstk = m->next_active;
4163 if (m->name)
4166 * This was a real macro call, not a %rep, and
4167 * therefore the parameter information needs to
4168 * be freed.
4170 nasm_free(m->params);
4171 free_tlist(m->iline);
4172 nasm_free(m->paramlen);
4173 l->finishes->in_progress = FALSE;
4175 else
4176 free_mmacro(m);
4178 istk->expansion = l->next;
4179 nasm_free(l);
4180 list->downlevel(LIST_MACRO);
4183 while (1)
4184 { /* until we get a line we can use */
4186 if (istk->expansion)
4187 { /* from a macro expansion */
4188 char *p;
4189 Line *l = istk->expansion;
4190 if (istk->mstk)
4191 istk->mstk->lineno++;
4192 tline = l->first;
4193 istk->expansion = l->next;
4194 nasm_free(l);
4195 p = detoken(tline, FALSE);
4196 list->line(LIST_MACRO, p);
4197 nasm_free(p);
4198 break;
4200 line = read_line();
4201 if (line)
4202 { /* from the current input file */
4203 line = prepreproc(line);
4204 tline = tokenise(line);
4205 nasm_free(line);
4206 break;
4209 * The current file has ended; work down the istk
4212 Include *i = istk;
4213 fclose(i->fp);
4214 if (i->conds)
4215 error(ERR_FATAL, "expected `%%endif' before end of file");
4216 /* only set line and file name if there's a next node */
4217 if (i->next)
4219 src_set_linnum(i->lineno);
4220 nasm_free(src_set_fname(i->fname));
4222 istk = i->next;
4223 list->downlevel(LIST_INCLUDE);
4224 nasm_free(i);
4225 if (!istk)
4226 return NULL;
4231 * We must expand MMacro parameters and MMacro-local labels
4232 * _before_ we plunge into directive processing, to cope
4233 * with things like `%define something %1' such as STRUC
4234 * uses. Unless we're _defining_ a MMacro, in which case
4235 * those tokens should be left alone to go into the
4236 * definition; and unless we're in a non-emitting
4237 * condition, in which case we don't want to meddle with
4238 * anything.
4240 if (!defining && !(istk->conds && !emitting(istk->conds->state)))
4241 tline = expand_mmac_params(tline);
4244 * Check the line to see if it's a preprocessor directive.
4246 if (do_directive(tline) == DIRECTIVE_FOUND)
4248 continue;
4250 else if (defining)
4253 * We're defining a multi-line macro. We emit nothing
4254 * at all, and just
4255 * shove the tokenised line on to the macro definition.
4257 Line *l = nasm_malloc(sizeof(Line));
4258 l->next = defining->expansion;
4259 l->first = tline;
4260 l->finishes = FALSE;
4261 defining->expansion = l;
4262 continue;
4264 else if (istk->conds && !emitting(istk->conds->state))
4267 * We're in a non-emitting branch of a condition block.
4268 * Emit nothing at all, not even a blank line: when we
4269 * emerge from the condition we'll give a line-number
4270 * directive so we keep our place correctly.
4272 free_tlist(tline);
4273 continue;
4275 else if (istk->mstk && !istk->mstk->in_progress)
4278 * We're in a %rep block which has been terminated, so
4279 * we're walking through to the %endrep without
4280 * emitting anything. Emit nothing at all, not even a
4281 * blank line: when we emerge from the %rep block we'll
4282 * give a line-number directive so we keep our place
4283 * correctly.
4285 free_tlist(tline);
4286 continue;
4288 else
4290 tline = expand_smacro(tline);
4291 if (!expand_mmacro(tline))
4294 * De-tokenise the line again, and emit it.
4296 line = detoken(tline, TRUE);
4297 free_tlist(tline);
4298 break;
4300 else
4302 continue; /* expand_mmacro calls free_tlist */
4307 return line;
4310 static void
4311 pp_cleanup(int pass)
4313 int h;
4315 if (defining)
4317 error(ERR_NONFATAL, "end of file while still defining macro `%s'",
4318 defining->name);
4319 free_mmacro(defining);
4321 while (cstk)
4322 ctx_pop();
4323 for (h = 0; h < NHASH; h++)
4325 while (mmacros[h])
4327 MMacro *m = mmacros[h];
4328 mmacros[h] = mmacros[h]->next;
4329 free_mmacro(m);
4331 while (smacros[h])
4333 SMacro *s = smacros[h];
4334 smacros[h] = smacros[h]->next;
4335 nasm_free(s->name);
4336 free_tlist(s->expansion);
4337 nasm_free(s);
4340 while (istk)
4342 Include *i = istk;
4343 istk = istk->next;
4344 fclose(i->fp);
4345 nasm_free(i->fname);
4346 nasm_free(i);
4348 while (cstk)
4349 ctx_pop();
4350 if (pass == 0)
4352 free_llist(predef);
4353 delete_Blocks();
4357 void
4358 pp_include_path(char *path)
4360 IncPath *i;
4361 /* by alexfru: order of path inclusion fixed (was reverse order) */
4362 i = nasm_malloc(sizeof(IncPath));
4363 i->path = nasm_strdup(path);
4364 i->next = NULL;
4366 if (ipath != NULL)
4368 IncPath *j = ipath;
4369 while (j->next != NULL)
4370 j = j->next;
4371 j->next = i;
4373 else
4375 ipath = i;
4380 * added by alexfru:
4382 * This function is used to "export" the include paths, e.g.
4383 * the paths specified in the '-I' command switch.
4384 * The need for such exporting is due to the 'incbin' directive,
4385 * which includes raw binary files (unlike '%include', which
4386 * includes text source files). It would be real nice to be
4387 * able to specify paths to search for incbin'ned files also.
4388 * So, this is a simple workaround.
4390 * The function use is simple:
4392 * The 1st call (with NULL argument) returns a pointer to the 1st path
4393 * (char** type) or NULL if none include paths available.
4395 * All subsequent calls take as argument the value returned by this
4396 * function last. The return value is either the next path
4397 * (char** type) or NULL if the end of the paths list is reached.
4399 * It is maybe not the best way to do things, but I didn't want
4400 * to export too much, just one or two functions and no types or
4401 * variables exported.
4403 * Can't say I like the current situation with e.g. this path list either,
4404 * it seems to be never deallocated after creation...
4406 char**
4407 pp_get_include_path_ptr (char **pPrevPath)
4409 /* This macro returns offset of a member of a structure */
4410 #define GetMemberOffset(StructType,MemberName)\
4411 ((size_t)&((StructType*)0)->MemberName)
4412 IncPath *i;
4414 if (pPrevPath == NULL)
4416 if(ipath != NULL)
4417 return &ipath->path;
4418 else
4419 return NULL;
4421 i = (IncPath*) ((char*)pPrevPath - GetMemberOffset(IncPath,path));
4422 i = i->next;
4423 if (i != NULL)
4424 return &i->path;
4425 else
4426 return NULL;
4427 #undef GetMemberOffset
4430 void
4431 pp_pre_include(char *fname)
4433 Token *inc, *space, *name;
4434 Line *l;
4436 name = new_Token(NULL, TOK_INTERNAL_STRING, fname, 0);
4437 space = new_Token(name, TOK_WHITESPACE, NULL, 0);
4438 inc = new_Token(space, TOK_PREPROC_ID, "%include", 0);
4440 l = nasm_malloc(sizeof(Line));
4441 l->next = predef;
4442 l->first = inc;
4443 l->finishes = FALSE;
4444 predef = l;
4447 void
4448 pp_pre_define(char *definition)
4450 Token *def, *space;
4451 Line *l;
4452 char *equals;
4454 equals = strchr(definition, '=');
4455 space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4456 def = new_Token(space, TOK_PREPROC_ID, "%define", 0);
4457 if (equals)
4458 *equals = ' ';
4459 space->next = tokenise(definition);
4460 if (equals)
4461 *equals = '=';
4463 l = nasm_malloc(sizeof(Line));
4464 l->next = predef;
4465 l->first = def;
4466 l->finishes = FALSE;
4467 predef = l;
4470 void
4471 pp_pre_undefine(char *definition)
4473 Token *def, *space;
4474 Line *l;
4476 space = new_Token(NULL, TOK_WHITESPACE, NULL, 0);
4477 def = new_Token(space, TOK_PREPROC_ID, "%undef", 0);
4478 space->next = tokenise(definition);
4480 l = nasm_malloc(sizeof(Line));
4481 l->next = predef;
4482 l->first = def;
4483 l->finishes = FALSE;
4484 predef = l;
4487 void
4488 pp_extra_stdmac(const char **macros)
4490 extrastdmac = macros;
4493 static void
4494 make_tok_num(Token * tok, long val)
4496 char numbuf[20];
4497 sprintf(numbuf, "%ld", val);
4498 tok->text = nasm_strdup(numbuf);
4499 tok->type = TOK_NUMBER;
4502 Preproc nasmpp = {
4503 pp_reset,
4504 pp_getline,
4505 pp_cleanup