1 /* preproc.c macro preprocessor for the Netwide Assembler
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the license given in the file "LICENSE"
6 * distributed in the NASM archive.
8 * initial version 18/iii/97 by Simon Tatham
11 /* Typical flow of text through preproc
13 * pp_getline gets tokenized lines, either
15 * from a macro expansion
19 * read_line gets raw text from stdmacpos, or predef, or current input file
20 * tokenize converts to tokens
23 * expand_mmac_params is used to expand %1 etc., unless a macro is being
24 * defined or a false conditional is being processed
25 * (%0, %1, %+1, %-1, %%foo
27 * do_directive checks for directives
29 * expand_smacro is used to expand single line macros
31 * expand_mmacro is used to expand multi-line macros
33 * detoken is used to convert the line back to text
56 typedef struct SMacro SMacro
;
57 typedef struct MMacro MMacro
;
58 typedef struct Context Context
;
59 typedef struct Token Token
;
60 typedef struct Blocks Blocks
;
61 typedef struct Line Line
;
62 typedef struct Include Include
;
63 typedef struct Cond Cond
;
64 typedef struct IncPath IncPath
;
67 * Note on the storage of both SMacro and MMacros: the hash table
68 * indexes them case-insensitively, and we then have to go through a
69 * linked list of potential case aliases (and, for MMacros, parameter
70 * ranges); this is to preserve the matching semantics of the earlier
71 * code. If the number of case aliases for a specific macro is a
72 * performance issue, you may want to reconsider your coding style.
76 * Store the definition of a single-line macro.
88 * Store the definition of a multi-line macro. This is also used to
89 * store the interiors of `%rep...%endrep' blocks, which are
90 * effectively self-re-invoking multi-line macros which simply
91 * don't have a name or bother to appear in the hash tables. %rep
92 * blocks are signified by having a NULL `name' field.
94 * In a MMacro describing a `%rep' block, the `in_progress' field
95 * isn't merely boolean, but gives the number of repeats left to
98 * The `next' field is used for storing MMacros in hash tables; the
99 * `next_active' field is for stacking them on istk entries.
101 * When a MMacro is being expanded, `params', `iline', `nparam',
102 * `paramlen', `rotate' and `unique' are local to the invocation.
107 int nparam_min
, nparam_max
;
109 bool plus
; /* is the last parameter greedy? */
110 bool nolist
; /* is this macro listing-inhibited? */
112 Token
*dlist
; /* All defaults as one list */
113 Token
**defaults
; /* Parameter default pointers */
114 int ndefs
; /* number of default parameters */
118 MMacro
*rep_nest
; /* used for nesting %rep */
119 Token
**params
; /* actual parameters */
120 Token
*iline
; /* invocation line */
121 unsigned int nparam
, rotate
;
124 int lineno
; /* Current line number on expansion */
128 * The context stack is composed of a linked list of these.
133 struct hash_table localmac
;
138 * This is the internal form which we break input lines up into.
139 * Typically stored in linked lists.
141 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
142 * necessarily used as-is, but is intended to denote the number of
143 * the substituted parameter. So in the definition
145 * %define a(x,y) ( (x) & ~(y) )
147 * the token representing `x' will have its type changed to
148 * TOK_SMAC_PARAM, but the one representing `y' will be
151 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
152 * which doesn't need quotes around it. Used in the pre-include
153 * mechanism as an alternative to trying to find a sensible type of
154 * quote to use on the filename we were passed.
157 TOK_NONE
= 0, TOK_WHITESPACE
, TOK_COMMENT
, TOK_ID
,
158 TOK_PREPROC_ID
, TOK_STRING
,
159 TOK_NUMBER
, TOK_FLOAT
, TOK_SMAC_END
, TOK_OTHER
,
161 TOK_PREPROC_Q
, TOK_PREPROC_QQ
,
162 TOK_SMAC_PARAM
, /* MUST BE LAST IN THE LIST!!! */
163 TOK_MAX
= INT_MAX
/* Keep compiler from reducing the range */
170 SMacro
*mac
; /* associated macro for TOK_SMAC_END */
171 size_t len
; /* scratch length field */
172 } a
; /* Auxiliary data */
173 enum pp_token_type type
;
177 * Multi-line macro definitions are stored as a linked list of
178 * these, which is essentially a container to allow several linked
181 * Note that in this module, linked lists are treated as stacks
182 * wherever possible. For this reason, Lines are _pushed_ on to the
183 * `expansion' field in MMacro structures, so that the linked list,
184 * if walked, would give the macro lines in reverse order; this
185 * means that we can walk the list when expanding a macro, and thus
186 * push the lines on to the `expansion' field in _istk_ in reverse
187 * order (so that when popped back off they are in the right
188 * order). It may seem cockeyed, and it relies on my design having
189 * an even number of steps in, but it works...
191 * Some of these structures, rather than being actual lines, are
192 * markers delimiting the end of the expansion of a given macro.
193 * This is for use in the cycle-tracking and %rep-handling code.
194 * Such structures have `finishes' non-NULL, and `first' NULL. All
195 * others have `finishes' NULL, but `first' may still be NULL if
205 * To handle an arbitrary level of file inclusion, we maintain a
206 * stack (ie linked list) of these things.
215 MMacro
*mstk
; /* stack of active macros/reps */
219 * Include search path. This is simply a list of strings which get
220 * prepended, in turn, to the name of an include file, in an
221 * attempt to find the file if it's not in the current directory.
229 * Conditional assembly: we maintain a separate stack of these for
230 * each level of file inclusion. (The only reason we keep the
231 * stacks separate is to ensure that a stray `%endif' in a file
232 * included from within the true branch of a `%if' won't terminate
233 * it and cause confusion: instead, rightly, it'll cause an error.)
241 * These states are for use just after %if or %elif: IF_TRUE
242 * means the condition has evaluated to truth so we are
243 * currently emitting, whereas IF_FALSE means we are not
244 * currently emitting but will start doing so if a %else comes
245 * up. In these states, all directives are admissible: %elif,
246 * %else and %endif. (And of course %if.)
248 COND_IF_TRUE
, COND_IF_FALSE
,
250 * These states come up after a %else: ELSE_TRUE means we're
251 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
252 * any %elif or %else will cause an error.
254 COND_ELSE_TRUE
, COND_ELSE_FALSE
,
256 * This state means that we're not emitting now, and also that
257 * nothing until %endif will be emitted at all. It's for use in
258 * two circumstances: (i) when we've had our moment of emission
259 * and have now started seeing %elifs, and (ii) when the
260 * condition construct in question is contained within a
261 * non-emitting branch of a larger condition construct.
265 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
268 * These defines are used as the possible return values for do_directive
270 #define NO_DIRECTIVE_FOUND 0
271 #define DIRECTIVE_FOUND 1
274 * Condition codes. Note that we use c_ prefix not C_ because C_ is
275 * used in nasm.h for the "real" condition codes. At _this_ level,
276 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
277 * ones, so we need a different enum...
279 static const char * const conditions
[] = {
280 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
281 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
282 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
285 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_CXZ
, c_E
, c_ECXZ
, c_G
, c_GE
, c_L
, c_LE
,
286 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, c_NE
, c_NG
, c_NGE
, c_NL
, c_NLE
, c_NO
,
287 c_NP
, c_NS
, c_NZ
, c_O
, c_P
, c_PE
, c_PO
, c_RCXZ
, c_S
, c_Z
,
290 static const enum pp_conds inverse_ccs
[] = {
291 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, -1, c_NE
, -1, c_NG
, c_NGE
, c_NL
, c_NLE
,
292 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_E
, c_G
, c_GE
, c_L
, c_LE
, c_O
, c_P
, c_S
,
293 c_Z
, c_NO
, c_NP
, c_PO
, c_PE
, -1, c_NS
, c_NZ
299 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
300 static int is_condition(enum preproc_token arg
)
302 return PP_IS_COND(arg
) || (arg
== PP_ELSE
) || (arg
== PP_ENDIF
);
305 /* For TASM compatibility we need to be able to recognise TASM compatible
306 * conditional compilation directives. Using the NASM pre-processor does
307 * not work, so we look for them specifically from the following list and
308 * then jam in the equivalent NASM directive into the input stream.
312 TM_ARG
, TM_ELIF
, TM_ELSE
, TM_ENDIF
, TM_IF
, TM_IFDEF
, TM_IFDIFI
,
313 TM_IFNDEF
, TM_INCLUDE
, TM_LOCAL
316 static const char * const tasm_directives
[] = {
317 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
318 "ifndef", "include", "local"
321 static int StackSize
= 4;
322 static char *StackPointer
= "ebp";
323 static int ArgOffset
= 8;
324 static int LocalOffset
= 0;
326 static Context
*cstk
;
327 static Include
*istk
;
328 static IncPath
*ipath
= NULL
;
330 static efunc _error
; /* Pointer to client-provided error reporting function */
331 static evalfunc evaluate
;
333 static int pass
; /* HACK: pass 0 = generate dependencies only */
334 static StrList
**dephead
, **deptail
; /* Dependency list */
336 static uint64_t unique
; /* unique identifier numbers */
338 static Line
*predef
= NULL
;
339 static bool do_predef
;
341 static ListGen
*list
;
344 * The current set of multi-line macros we have defined.
346 static struct hash_table mmacros
;
349 * The current set of single-line macros we have defined.
351 static struct hash_table smacros
;
354 * The multi-line macro we are currently defining, or the %rep
355 * block we are currently reading, if any.
357 static MMacro
*defining
;
359 static uint64_t nested_mac_count
;
360 static uint64_t nested_rep_count
;
363 * The number of macro parameters to allocate space for at a time.
365 #define PARAM_DELTA 16
368 * The standard macro set: defined in macros.c in the array nasm_stdmac.
369 * This gives our position in the macro set, when we're processing it.
371 static macros_t
*stdmacpos
;
374 * The extra standard macros that come from the object format, if
377 static macros_t
*extrastdmac
= NULL
;
378 static bool any_extrastdmac
;
381 * Tokens are allocated in blocks to improve speed
383 #define TOKEN_BLOCKSIZE 4096
384 static Token
*freeTokens
= NULL
;
390 static Blocks blocks
= { NULL
, NULL
};
393 * Forward declarations.
395 static Token
*expand_mmac_params(Token
* tline
);
396 static Token
*expand_smacro(Token
* tline
);
397 static Token
*expand_id(Token
* tline
);
398 static Context
*get_ctx(const char *name
, bool all_contexts
);
399 static void make_tok_num(Token
* tok
, int64_t val
);
400 static void error(int severity
, const char *fmt
, ...);
401 static void *new_Block(size_t size
);
402 static void delete_Blocks(void);
403 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
404 const char *text
, int txtlen
);
405 static Token
*delete_Token(Token
* t
);
408 * Macros for safe checking of token pointers, avoid *(NULL)
410 #define tok_type_(x,t) ((x) && (x)->type == (t))
411 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
412 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
413 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
415 /* Handle TASM specific directives, which do not contain a % in
416 * front of them. We do it here because I could not find any other
417 * place to do it for the moment, and it is a hack (ideally it would
418 * be nice to be able to use the NASM pre-processor to do it).
420 static char *check_tasm_directive(char *line
)
422 int32_t i
, j
, k
, m
, len
;
423 char *p
= line
, *oldline
, oldchar
;
425 /* Skip whitespace */
426 while (nasm_isspace(*p
) && *p
!= 0)
429 /* Binary search for the directive name */
431 j
= elements(tasm_directives
);
433 while (!nasm_isspace(p
[len
]) && p
[len
] != 0)
440 m
= nasm_stricmp(p
, tasm_directives
[k
]);
442 /* We have found a directive, so jam a % in front of it
443 * so that NASM will then recognise it as one if it's own.
448 line
= nasm_malloc(len
+ 2);
450 if (k
== TM_IFDIFI
) {
451 /* NASM does not recognise IFDIFI, so we convert it to
452 * %ifdef BOGUS. This is not used in NASM comaptible
453 * code, but does need to parse for the TASM macro
456 strcpy(line
+ 1, "ifdef BOGUS");
458 memcpy(line
+ 1, p
, len
+ 1);
473 * The pre-preprocessing stage... This function translates line
474 * number indications as they emerge from GNU cpp (`# lineno "file"
475 * flags') into NASM preprocessor line number indications (`%line
478 static char *prepreproc(char *line
)
481 char *fname
, *oldline
;
483 if (line
[0] == '#' && line
[1] == ' ') {
486 lineno
= atoi(fname
);
487 fname
+= strspn(fname
, "0123456789 ");
490 fnlen
= strcspn(fname
, "\"");
491 line
= nasm_malloc(20 + fnlen
);
492 snprintf(line
, 20 + fnlen
, "%%line %d %.*s", lineno
, fnlen
, fname
);
495 if (tasm_compatible_mode
)
496 return check_tasm_directive(line
);
501 * Free a linked list of tokens.
503 static void free_tlist(Token
* list
)
506 list
= delete_Token(list
);
511 * Free a linked list of lines.
513 static void free_llist(Line
* list
)
519 free_tlist(l
->first
);
527 static void free_mmacro(MMacro
* m
)
530 free_tlist(m
->dlist
);
531 nasm_free(m
->defaults
);
532 free_llist(m
->expansion
);
537 * Free all currently defined macros, and free the hash tables
539 static void free_smacro_table(struct hash_table
*smt
)
543 struct hash_tbl_node
*it
= NULL
;
545 while ((s
= hash_iterate(smt
, &it
, &key
)) != NULL
) {
546 nasm_free((void *)key
);
548 SMacro
*ns
= s
->next
;
550 free_tlist(s
->expansion
);
558 static void free_mmacro_table(struct hash_table
*mmt
)
562 struct hash_tbl_node
*it
= NULL
;
565 while ((m
= hash_iterate(mmt
, &it
, &key
)) != NULL
) {
566 nasm_free((void *)key
);
568 MMacro
*nm
= m
->next
;
576 static void free_macros(void)
578 free_smacro_table(&smacros
);
579 free_mmacro_table(&mmacros
);
583 * Initialize the hash tables
585 static void init_macros(void)
587 hash_init(&smacros
, HASH_LARGE
);
588 hash_init(&mmacros
, HASH_LARGE
);
592 * Pop the context stack.
594 static void ctx_pop(void)
599 free_smacro_table(&c
->localmac
);
605 * Search for a key in the hash index; adding it if necessary
606 * (in which case we initialize the data pointer to NULL.)
609 hash_findi_add(struct hash_table
*hash
, const char *str
)
611 struct hash_insert hi
;
615 r
= hash_findi(hash
, str
, &hi
);
619 strx
= nasm_strdup(str
); /* Use a more efficient allocator here? */
620 return hash_add(&hi
, strx
, NULL
);
624 * Like hash_findi, but returns the data element rather than a pointer
625 * to it. Used only when not adding a new element, hence no third
629 hash_findix(struct hash_table
*hash
, const char *str
)
633 p
= hash_findi(hash
, str
, NULL
);
634 return p
? *p
: NULL
;
637 #define BUF_DELTA 512
639 * Read a line from the top file in istk, handling multiple CR/LFs
640 * at the end of the line read, and handling spurious ^Zs. Will
641 * return lines from the standard macro set if this has not already
644 static char *read_line(void)
646 char *buffer
, *p
, *q
;
647 int bufsize
, continued_count
;
651 const unsigned char *p
= stdmacpos
;
656 len
+= pp_directives_len
[c
-0x80]+1;
660 ret
= nasm_malloc(len
+1);
662 while ((c
= *stdmacpos
++)) {
664 memcpy(q
, pp_directives
[c
-0x80], pp_directives_len
[c
-0x80]);
665 q
+= pp_directives_len
[c
-0x80];
675 /* This was the last of the standard macro chain... */
677 if (any_extrastdmac
) {
678 stdmacpos
= extrastdmac
;
679 any_extrastdmac
= false;
680 } else if (do_predef
) {
682 Token
*head
, **tail
, *t
;
685 * Nasty hack: here we push the contents of
686 * `predef' on to the top-level expansion stack,
687 * since this is the most convenient way to
688 * implement the pre-include and pre-define
691 for (pd
= predef
; pd
; pd
= pd
->next
) {
694 for (t
= pd
->first
; t
; t
= t
->next
) {
695 *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
696 tail
= &(*tail
)->next
;
698 l
= nasm_malloc(sizeof(Line
));
699 l
->next
= istk
->expansion
;
711 buffer
= nasm_malloc(BUF_DELTA
);
715 q
= fgets(p
, bufsize
- (p
- buffer
), istk
->fp
);
719 if (p
> buffer
&& p
[-1] == '\n') {
720 /* Convert backslash-CRLF line continuation sequences into
721 nothing at all (for DOS and Windows) */
722 if (((p
- 2) > buffer
) && (p
[-3] == '\\') && (p
[-2] == '\r')) {
727 /* Also convert backslash-LF line continuation sequences into
728 nothing at all (for Unix) */
729 else if (((p
- 1) > buffer
) && (p
[-2] == '\\')) {
737 if (p
- buffer
> bufsize
- 10) {
738 int32_t offset
= p
- buffer
;
739 bufsize
+= BUF_DELTA
;
740 buffer
= nasm_realloc(buffer
, bufsize
);
741 p
= buffer
+ offset
; /* prevent stale-pointer problems */
745 if (!q
&& p
== buffer
) {
750 src_set_linnum(src_get_linnum() + istk
->lineinc
+
751 (continued_count
* istk
->lineinc
));
754 * Play safe: remove CRs as well as LFs, if any of either are
755 * present at the end of the line.
757 while (--p
>= buffer
&& (*p
== '\n' || *p
== '\r'))
761 * Handle spurious ^Z, which may be inserted into source files
762 * by some file transfer utilities.
764 buffer
[strcspn(buffer
, "\032")] = '\0';
766 list
->line(LIST_READ
, buffer
);
772 * Tokenize a line of text. This is a very simple process since we
773 * don't need to parse the value out of e.g. numeric tokens: we
774 * simply split one string into many.
776 static Token
*tokenize(char *line
)
779 enum pp_token_type type
;
781 Token
*t
, **tail
= &list
;
787 if (nasm_isdigit(*p
) ||
788 ((*p
== '-' || *p
== '+') && nasm_isdigit(p
[1])) ||
789 ((*p
== '+') && (nasm_isspace(p
[1]) || !p
[1]))) {
793 while (nasm_isdigit(*p
));
794 type
= TOK_PREPROC_ID
;
795 } else if (*p
== '{') {
797 while (*p
&& *p
!= '}') {
804 type
= TOK_PREPROC_ID
;
805 } else if (*p
== '?') {
806 type
= TOK_PREPROC_Q
; /* %? */
809 type
= TOK_PREPROC_QQ
; /* %?? */
812 } else if (isidchar(*p
) ||
813 ((*p
== '!' || *p
== '%' || *p
== '$') &&
818 while (isidchar(*p
));
819 type
= TOK_PREPROC_ID
;
825 } else if (isidstart(*p
) || (*p
== '$' && isidstart(p
[1]))) {
828 while (*p
&& isidchar(*p
))
830 } else if (*p
== '\'' || *p
== '"' || *p
== '`') {
835 p
= nasm_skip_string(p
);
840 error(ERR_WARNING
, "unterminated string");
841 /* Handling unterminated strings by UNV */
844 } else if (isnumstart(*p
)) {
846 bool is_float
= false;
862 if (!is_hex
&& (c
== 'e' || c
== 'E')) {
864 if (*p
== '+' || *p
== '-') {
865 /* e can only be followed by +/- if it is either a
866 prefixed hex number or a floating-point number */
870 } else if (c
== 'H' || c
== 'h' || c
== 'X' || c
== 'x') {
872 } else if (c
== 'P' || c
== 'p') {
874 if (*p
== '+' || *p
== '-')
876 } else if (isnumchar(c
) || c
== '_')
879 /* we need to deal with consequences of the legacy
880 parser, like "1.nolist" being two tokens
881 (TOK_NUMBER, TOK_ID) here; at least give it
882 a shot for now. In the future, we probably need
883 a flex-based scanner with proper pattern matching
884 to do it as well as it can be done. Nothing in
885 the world is going to help the person who wants
886 0x123.p16 interpreted as two tokens, though. */
891 if (nasm_isdigit(*r
) || (is_hex
&& nasm_isxdigit(*r
)) ||
892 (!is_hex
&& (*r
== 'e' || *r
== 'E')) ||
893 (*r
== 'p' || *r
== 'P')) {
897 break; /* Terminate the token */
901 p
--; /* Point to first character beyond number */
903 if (has_e
&& !is_hex
) {
904 /* 1e13 is floating-point, but 1e13h is not */
908 type
= is_float
? TOK_FLOAT
: TOK_NUMBER
;
909 } else if (nasm_isspace(*p
)) {
910 type
= TOK_WHITESPACE
;
912 while (*p
&& nasm_isspace(*p
))
915 * Whitespace just before end-of-line is discarded by
916 * pretending it's a comment; whitespace just before a
917 * comment gets lumped into the comment.
919 if (!*p
|| *p
== ';') {
924 } else if (*p
== ';') {
930 * Anything else is an operator of some kind. We check
931 * for all the double-character operators (>>, <<, //,
932 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
933 * else is a single-character operator.
936 if ((p
[0] == '>' && p
[1] == '>') ||
937 (p
[0] == '<' && p
[1] == '<') ||
938 (p
[0] == '/' && p
[1] == '/') ||
939 (p
[0] == '<' && p
[1] == '=') ||
940 (p
[0] == '>' && p
[1] == '=') ||
941 (p
[0] == '=' && p
[1] == '=') ||
942 (p
[0] == '!' && p
[1] == '=') ||
943 (p
[0] == '<' && p
[1] == '>') ||
944 (p
[0] == '&' && p
[1] == '&') ||
945 (p
[0] == '|' && p
[1] == '|') ||
946 (p
[0] == '^' && p
[1] == '^')) {
952 /* Handling unterminated string by UNV */
955 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
956 t->text[p-line] = *line;
960 if (type
!= TOK_COMMENT
) {
961 *tail
= t
= new_Token(NULL
, type
, line
, p
- line
);
970 * this function allocates a new managed block of memory and
971 * returns a pointer to the block. The managed blocks are
972 * deleted only all at once by the delete_Blocks function.
974 static void *new_Block(size_t size
)
978 /* first, get to the end of the linked list */
981 /* now allocate the requested chunk */
982 b
->chunk
= nasm_malloc(size
);
984 /* now allocate a new block for the next request */
985 b
->next
= nasm_malloc(sizeof(Blocks
));
986 /* and initialize the contents of the new block */
987 b
->next
->next
= NULL
;
988 b
->next
->chunk
= NULL
;
993 * this function deletes all managed blocks of memory
995 static void delete_Blocks(void)
997 Blocks
*a
, *b
= &blocks
;
1000 * keep in mind that the first block, pointed to by blocks
1001 * is a static and not dynamically allocated, so we don't
1006 nasm_free(b
->chunk
);
1015 * this function creates a new Token and passes a pointer to it
1016 * back to the caller. It sets the type and text elements, and
1017 * also the a.mac and next elements to NULL.
1019 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
1020 const char *text
, int txtlen
)
1025 if (freeTokens
== NULL
) {
1026 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
1027 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
1028 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
1029 freeTokens
[i
].next
= NULL
;
1032 freeTokens
= t
->next
;
1036 if (type
== TOK_WHITESPACE
|| text
== NULL
) {
1040 txtlen
= strlen(text
);
1041 t
->text
= nasm_malloc(txtlen
+1);
1042 memcpy(t
->text
, text
, txtlen
);
1043 t
->text
[txtlen
] = '\0';
1048 static Token
*delete_Token(Token
* t
)
1050 Token
*next
= t
->next
;
1052 t
->next
= freeTokens
;
1058 * Convert a line of tokens back into text.
1059 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1060 * will be transformed into ..@ctxnum.xxx
1062 static char *detoken(Token
* tlist
, bool expand_locals
)
1070 for (t
= tlist
; t
; t
= t
->next
) {
1071 if (t
->type
== TOK_PREPROC_ID
&& t
->text
[1] == '!') {
1072 char *p
= getenv(t
->text
+ 2);
1075 t
->text
= nasm_strdup(p
);
1079 /* Expand local macros here and not during preprocessing */
1080 if (expand_locals
&&
1081 t
->type
== TOK_PREPROC_ID
&& t
->text
&&
1082 t
->text
[0] == '%' && t
->text
[1] == '$') {
1083 Context
*ctx
= get_ctx(t
->text
, false);
1086 char *p
, *q
= t
->text
+ 2;
1088 q
+= strspn(q
, "$");
1089 snprintf(buffer
, sizeof(buffer
), "..@%"PRIu32
".", ctx
->number
);
1090 p
= nasm_strcat(buffer
, q
);
1095 if (t
->type
== TOK_WHITESPACE
) {
1097 } else if (t
->text
) {
1098 len
+= strlen(t
->text
);
1101 p
= line
= nasm_malloc(len
+ 1);
1102 for (t
= tlist
; t
; t
= t
->next
) {
1103 if (t
->type
== TOK_WHITESPACE
) {
1105 } else if (t
->text
) {
1116 * A scanner, suitable for use by the expression evaluator, which
1117 * operates on a line of Tokens. Expects a pointer to a pointer to
1118 * the first token in the line to be passed in as its private_data
1121 * FIX: This really needs to be unified with stdscan.
1123 static int ppscan(void *private_data
, struct tokenval
*tokval
)
1125 Token
**tlineptr
= private_data
;
1127 char ourcopy
[MAX_KEYWORD
+1], *p
, *r
, *s
;
1131 *tlineptr
= tline
? tline
->next
: NULL
;
1133 while (tline
&& (tline
->type
== TOK_WHITESPACE
||
1134 tline
->type
== TOK_COMMENT
));
1137 return tokval
->t_type
= TOKEN_EOS
;
1139 tokval
->t_charptr
= tline
->text
;
1141 if (tline
->text
[0] == '$' && !tline
->text
[1])
1142 return tokval
->t_type
= TOKEN_HERE
;
1143 if (tline
->text
[0] == '$' && tline
->text
[1] == '$' && !tline
->text
[2])
1144 return tokval
->t_type
= TOKEN_BASE
;
1146 if (tline
->type
== TOK_ID
) {
1147 p
= tokval
->t_charptr
= tline
->text
;
1149 tokval
->t_charptr
++;
1150 return tokval
->t_type
= TOKEN_ID
;
1153 for (r
= p
, s
= ourcopy
; *r
; r
++) {
1154 if (r
>= p
+MAX_KEYWORD
)
1155 return tokval
->t_type
= TOKEN_ID
; /* Not a keyword */
1156 *s
++ = nasm_tolower(*r
);
1159 /* right, so we have an identifier sitting in temp storage. now,
1160 * is it actually a register or instruction name, or what? */
1161 return nasm_token_hash(ourcopy
, tokval
);
1164 if (tline
->type
== TOK_NUMBER
) {
1166 tokval
->t_integer
= readnum(tline
->text
, &rn_error
);
1167 tokval
->t_charptr
= tline
->text
;
1169 return tokval
->t_type
= TOKEN_ERRNUM
;
1171 return tokval
->t_type
= TOKEN_NUM
;
1174 if (tline
->type
== TOK_FLOAT
) {
1175 return tokval
->t_type
= TOKEN_FLOAT
;
1178 if (tline
->type
== TOK_STRING
) {
1181 bq
= tline
->text
[0];
1182 tokval
->t_charptr
= tline
->text
;
1183 tokval
->t_inttwo
= nasm_unquote(tline
->text
, &ep
);
1185 if (ep
[0] != bq
|| ep
[1] != '\0')
1186 return tokval
->t_type
= TOKEN_ERRSTR
;
1188 return tokval
->t_type
= TOKEN_STR
;
1191 if (tline
->type
== TOK_OTHER
) {
1192 if (!strcmp(tline
->text
, "<<"))
1193 return tokval
->t_type
= TOKEN_SHL
;
1194 if (!strcmp(tline
->text
, ">>"))
1195 return tokval
->t_type
= TOKEN_SHR
;
1196 if (!strcmp(tline
->text
, "//"))
1197 return tokval
->t_type
= TOKEN_SDIV
;
1198 if (!strcmp(tline
->text
, "%%"))
1199 return tokval
->t_type
= TOKEN_SMOD
;
1200 if (!strcmp(tline
->text
, "=="))
1201 return tokval
->t_type
= TOKEN_EQ
;
1202 if (!strcmp(tline
->text
, "<>"))
1203 return tokval
->t_type
= TOKEN_NE
;
1204 if (!strcmp(tline
->text
, "!="))
1205 return tokval
->t_type
= TOKEN_NE
;
1206 if (!strcmp(tline
->text
, "<="))
1207 return tokval
->t_type
= TOKEN_LE
;
1208 if (!strcmp(tline
->text
, ">="))
1209 return tokval
->t_type
= TOKEN_GE
;
1210 if (!strcmp(tline
->text
, "&&"))
1211 return tokval
->t_type
= TOKEN_DBL_AND
;
1212 if (!strcmp(tline
->text
, "^^"))
1213 return tokval
->t_type
= TOKEN_DBL_XOR
;
1214 if (!strcmp(tline
->text
, "||"))
1215 return tokval
->t_type
= TOKEN_DBL_OR
;
1219 * We have no other options: just return the first character of
1222 return tokval
->t_type
= tline
->text
[0];
1226 * Compare a string to the name of an existing macro; this is a
1227 * simple wrapper which calls either strcmp or nasm_stricmp
1228 * depending on the value of the `casesense' parameter.
1230 static int mstrcmp(const char *p
, const char *q
, bool casesense
)
1232 return casesense
? strcmp(p
, q
) : nasm_stricmp(p
, q
);
1236 * Compare a string to the name of an existing macro; this is a
1237 * simple wrapper which calls either strcmp or nasm_stricmp
1238 * depending on the value of the `casesense' parameter.
1240 static int mmemcmp(const char *p
, const char *q
, size_t l
, bool casesense
)
1242 return casesense
? memcmp(p
, q
, l
) : nasm_memicmp(p
, q
, l
);
1246 * Return the Context structure associated with a %$ token. Return
1247 * NULL, having _already_ reported an error condition, if the
1248 * context stack isn't deep enough for the supplied number of $
1250 * If all_contexts == true, contexts that enclose current are
1251 * also scanned for such smacro, until it is found; if not -
1252 * only the context that directly results from the number of $'s
1253 * in variable's name.
1255 static Context
*get_ctx(const char *name
, bool all_contexts
)
1261 if (!name
|| name
[0] != '%' || name
[1] != '$')
1265 error(ERR_NONFATAL
, "`%s': context stack is empty", name
);
1269 for (i
= strspn(name
+ 2, "$"), ctx
= cstk
; (i
> 0) && ctx
; i
--) {
1271 /* i--; Lino - 02/25/02 */
1274 error(ERR_NONFATAL
, "`%s': context stack is only"
1275 " %d level%s deep", name
, i
- 1, (i
== 2 ? "" : "s"));
1282 /* Search for this smacro in found context */
1283 m
= hash_findix(&ctx
->localmac
, name
);
1285 if (!mstrcmp(m
->name
, name
, m
->casesense
))
1296 * Check to see if a file is already in a string list
1298 static bool in_list(const StrList
*list
, const char *str
)
1301 if (!strcmp(list
->str
, str
))
1309 * Open an include file. This routine must always return a valid
1310 * file pointer if it returns - it's responsible for throwing an
1311 * ERR_FATAL and bombing out completely if not. It should also try
1312 * the include path one by one until it finds the file or reaches
1313 * the end of the path.
1315 static FILE *inc_fopen(const char *file
, StrList
**dhead
, StrList
***dtail
,
1320 IncPath
*ip
= ipath
;
1321 int len
= strlen(file
);
1322 size_t prefix_len
= 0;
1326 sl
= nasm_malloc(prefix_len
+len
+1+sizeof sl
->next
);
1327 memcpy(sl
->str
, prefix
, prefix_len
);
1328 memcpy(sl
->str
+prefix_len
, file
, len
+1);
1329 fp
= fopen(sl
->str
, "r");
1330 if (fp
&& dhead
&& !in_list(*dhead
, sl
->str
)) {
1348 prefix_len
= strlen(prefix
);
1350 /* -MG given and file not found */
1351 if (dhead
&& !in_list(*dhead
, file
)) {
1352 sl
= nasm_malloc(len
+1+sizeof sl
->next
);
1354 strcpy(sl
->str
, file
);
1362 error(ERR_FATAL
, "unable to open include file `%s'", file
);
1363 return NULL
; /* never reached - placate compilers */
1367 * Determine if we should warn on defining a single-line macro of
1368 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1369 * return true if _any_ single-line macro of that name is defined.
1370 * Otherwise, will return true if a single-line macro with either
1371 * `nparam' or no parameters is defined.
1373 * If a macro with precisely the right number of parameters is
1374 * defined, or nparam is -1, the address of the definition structure
1375 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1376 * is NULL, no action will be taken regarding its contents, and no
1379 * Note that this is also called with nparam zero to resolve
1382 * If you already know which context macro belongs to, you can pass
1383 * the context pointer as first parameter; if you won't but name begins
1384 * with %$ the context will be automatically computed. If all_contexts
1385 * is true, macro will be searched in outer contexts as well.
1388 smacro_defined(Context
* ctx
, const char *name
, int nparam
, SMacro
** defn
,
1391 struct hash_table
*smtbl
;
1395 smtbl
= &ctx
->localmac
;
1396 } else if (name
[0] == '%' && name
[1] == '$') {
1398 ctx
= get_ctx(name
, false);
1400 return false; /* got to return _something_ */
1401 smtbl
= &ctx
->localmac
;
1405 m
= (SMacro
*) hash_findix(smtbl
, name
);
1408 if (!mstrcmp(m
->name
, name
, m
->casesense
&& nocase
) &&
1409 (nparam
<= 0 || m
->nparam
== 0 || nparam
== (int) m
->nparam
)) {
1411 if (nparam
== (int) m
->nparam
|| nparam
== -1)
1425 * Count and mark off the parameters in a multi-line macro call.
1426 * This is called both from within the multi-line macro expansion
1427 * code, and also to mark off the default parameters when provided
1428 * in a %macro definition line.
1430 static void count_mmac_params(Token
* t
, int *nparam
, Token
*** params
)
1432 int paramsize
, brace
;
1434 *nparam
= paramsize
= 0;
1437 if (*nparam
>= paramsize
) {
1438 paramsize
+= PARAM_DELTA
;
1439 *params
= nasm_realloc(*params
, sizeof(**params
) * paramsize
);
1443 if (tok_is_(t
, "{"))
1445 (*params
)[(*nparam
)++] = t
;
1446 while (tok_isnt_(t
, brace
? "}" : ","))
1448 if (t
) { /* got a comma/brace */
1452 * Now we've found the closing brace, look further
1456 if (tok_isnt_(t
, ",")) {
1458 "braces do not enclose all of macro parameter");
1459 while (tok_isnt_(t
, ","))
1463 t
= t
->next
; /* eat the comma */
1470 * Determine whether one of the various `if' conditions is true or
1473 * We must free the tline we get passed.
1475 static bool if_condition(Token
* tline
, enum preproc_token ct
)
1477 enum pp_conditional i
= PP_COND(ct
);
1479 Token
*t
, *tt
, **tptr
, *origline
;
1480 struct tokenval tokval
;
1482 enum pp_token_type needtype
;
1488 j
= false; /* have we matched yet? */
1493 if (tline
->type
!= TOK_ID
) {
1495 "`%s' expects context identifiers", pp_directives
[ct
]);
1496 free_tlist(origline
);
1499 if (cstk
&& cstk
->name
&& !nasm_stricmp(tline
->text
, cstk
->name
))
1501 tline
= tline
->next
;
1506 j
= false; /* have we matched yet? */
1509 if (!tline
|| (tline
->type
!= TOK_ID
&&
1510 (tline
->type
!= TOK_PREPROC_ID
||
1511 tline
->text
[1] != '$'))) {
1513 "`%s' expects macro identifiers", pp_directives
[ct
]);
1516 if (smacro_defined(NULL
, tline
->text
, 0, NULL
, true))
1518 tline
= tline
->next
;
1524 tline
= expand_smacro(tline
);
1526 while (tok_isnt_(tt
, ","))
1530 "`%s' expects two comma-separated arguments",
1535 j
= true; /* assume equality unless proved not */
1536 while ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) && tt
) {
1537 if (tt
->type
== TOK_OTHER
&& !strcmp(tt
->text
, ",")) {
1538 error(ERR_NONFATAL
, "`%s': more than one comma on line",
1542 if (t
->type
== TOK_WHITESPACE
) {
1546 if (tt
->type
== TOK_WHITESPACE
) {
1550 if (tt
->type
!= t
->type
) {
1551 j
= false; /* found mismatching tokens */
1554 /* When comparing strings, need to unquote them first */
1555 if (t
->type
== TOK_STRING
) {
1556 size_t l1
= nasm_unquote(t
->text
, NULL
);
1557 size_t l2
= nasm_unquote(tt
->text
, NULL
);
1563 if (mmemcmp(t
->text
, tt
->text
, l1
, i
== PPC_IFIDN
)) {
1567 } else if (mstrcmp(tt
->text
, t
->text
, i
== PPC_IFIDN
) != 0) {
1568 j
= false; /* found mismatching tokens */
1575 if ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) || tt
)
1576 j
= false; /* trailing gunk on one end or other */
1582 MMacro searching
, *mmac
;
1584 tline
= tline
->next
;
1586 tline
= expand_id(tline
);
1587 if (!tok_type_(tline
, TOK_ID
)) {
1589 "`%s' expects a macro name", pp_directives
[ct
]);
1592 searching
.name
= nasm_strdup(tline
->text
);
1593 searching
.casesense
= true;
1594 searching
.plus
= false;
1595 searching
.nolist
= false;
1596 searching
.in_progress
= 0;
1597 searching
.rep_nest
= NULL
;
1598 searching
.nparam_min
= 0;
1599 searching
.nparam_max
= INT_MAX
;
1600 tline
= expand_smacro(tline
->next
);
1603 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
1605 "`%s' expects a parameter count or nothing",
1608 searching
.nparam_min
= searching
.nparam_max
=
1609 readnum(tline
->text
, &j
);
1612 "unable to parse parameter count `%s'",
1615 if (tline
&& tok_is_(tline
->next
, "-")) {
1616 tline
= tline
->next
->next
;
1617 if (tok_is_(tline
, "*"))
1618 searching
.nparam_max
= INT_MAX
;
1619 else if (!tok_type_(tline
, TOK_NUMBER
))
1621 "`%s' expects a parameter count after `-'",
1624 searching
.nparam_max
= readnum(tline
->text
, &j
);
1627 "unable to parse parameter count `%s'",
1629 if (searching
.nparam_min
> searching
.nparam_max
)
1631 "minimum parameter count exceeds maximum");
1634 if (tline
&& tok_is_(tline
->next
, "+")) {
1635 tline
= tline
->next
;
1636 searching
.plus
= true;
1638 mmac
= (MMacro
*) hash_findix(&mmacros
, searching
.name
);
1640 if (!strcmp(mmac
->name
, searching
.name
) &&
1641 (mmac
->nparam_min
<= searching
.nparam_max
1643 && (searching
.nparam_min
<= mmac
->nparam_max
1650 if(tline
&& tline
->next
)
1651 error(ERR_WARNING
, "trailing garbage after %%ifmacro ignored");
1652 nasm_free(searching
.name
);
1661 needtype
= TOK_NUMBER
;
1664 needtype
= TOK_STRING
;
1668 t
= tline
= expand_smacro(tline
);
1670 while (tok_type_(t
, TOK_WHITESPACE
) ||
1671 (needtype
== TOK_NUMBER
&&
1672 tok_type_(t
, TOK_OTHER
) &&
1673 (t
->text
[0] == '-' || t
->text
[0] == '+') &&
1677 j
= tok_type_(t
, needtype
);
1681 t
= tline
= expand_smacro(tline
);
1682 while (tok_type_(t
, TOK_WHITESPACE
))
1687 t
= t
->next
; /* Skip the actual token */
1688 while (tok_type_(t
, TOK_WHITESPACE
))
1690 j
= !t
; /* Should be nothing left */
1695 t
= tline
= expand_smacro(tline
);
1696 while (tok_type_(t
, TOK_WHITESPACE
))
1699 j
= !t
; /* Should be empty */
1703 t
= tline
= expand_smacro(tline
);
1705 tokval
.t_type
= TOKEN_INVALID
;
1706 evalresult
= evaluate(ppscan
, tptr
, &tokval
,
1707 NULL
, pass
| CRITICAL
, error
, NULL
);
1712 "trailing garbage after expression ignored");
1713 if (!is_simple(evalresult
)) {
1715 "non-constant value given to `%s'", pp_directives
[ct
]);
1718 j
= reloc_value(evalresult
) != 0;
1723 "preprocessor directive `%s' not yet implemented",
1728 free_tlist(origline
);
1729 return j
^ PP_NEGATIVE(ct
);
1732 free_tlist(origline
);
1737 * Common code for defining an smacro
1739 static bool define_smacro(Context
*ctx
, char *mname
, bool casesense
,
1740 int nparam
, Token
*expansion
)
1742 SMacro
*smac
, **smhead
;
1743 struct hash_table
*smtbl
;
1745 if (smacro_defined(ctx
, mname
, nparam
, &smac
, casesense
)) {
1748 "single-line macro `%s' defined both with and"
1749 " without parameters", mname
);
1751 /* Some instances of the old code considered this a failure,
1752 some others didn't. What is the right thing to do here? */
1753 free_tlist(expansion
);
1754 return false; /* Failure */
1757 * We're redefining, so we have to take over an
1758 * existing SMacro structure. This means freeing
1759 * what was already in it.
1761 nasm_free(smac
->name
);
1762 free_tlist(smac
->expansion
);
1765 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1766 smhead
= (SMacro
**) hash_findi_add(smtbl
, mname
);
1767 smac
= nasm_malloc(sizeof(SMacro
));
1768 smac
->next
= *smhead
;
1771 smac
->name
= nasm_strdup(mname
);
1772 smac
->casesense
= casesense
;
1773 smac
->nparam
= nparam
;
1774 smac
->expansion
= expansion
;
1775 smac
->in_progress
= false;
1776 return true; /* Success */
1780 * Undefine an smacro
1782 static void undef_smacro(Context
*ctx
, const char *mname
)
1784 SMacro
**smhead
, *s
, **sp
;
1785 struct hash_table
*smtbl
;
1787 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1788 smhead
= (SMacro
**)hash_findi(smtbl
, mname
, NULL
);
1792 * We now have a macro name... go hunt for it.
1795 while ((s
= *sp
) != NULL
) {
1796 if (!mstrcmp(s
->name
, mname
, s
->casesense
)) {
1799 free_tlist(s
->expansion
);
1809 * Parse a mmacro specification.
1811 static bool parse_mmacro_spec(Token
*tline
, MMacro
*def
, const char *directive
)
1815 tline
= tline
->next
;
1817 tline
= expand_id(tline
);
1818 if (!tok_type_(tline
, TOK_ID
)) {
1819 error(ERR_NONFATAL
, "`%s' expects a macro name", directive
);
1823 def
->name
= nasm_strdup(tline
->text
);
1825 def
->nolist
= false;
1826 def
->in_progress
= 0;
1827 def
->rep_nest
= NULL
;
1828 def
->nparam_min
= 0;
1829 def
->nparam_max
= 0;
1831 tline
= expand_smacro(tline
->next
);
1833 if (!tok_type_(tline
, TOK_NUMBER
)) {
1834 error(ERR_NONFATAL
, "`%s' expects a parameter count", directive
);
1836 def
->nparam_min
= def
->nparam_max
=
1837 readnum(tline
->text
, &err
);
1840 "unable to parse parameter count `%s'", tline
->text
);
1842 if (tline
&& tok_is_(tline
->next
, "-")) {
1843 tline
= tline
->next
->next
;
1844 if (tok_is_(tline
, "*")) {
1845 def
->nparam_max
= INT_MAX
;
1846 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
1848 "`%s' expects a parameter count after `-'", directive
);
1850 def
->nparam_max
= readnum(tline
->text
, &err
);
1852 error(ERR_NONFATAL
, "unable to parse parameter count `%s'",
1855 if (def
->nparam_min
> def
->nparam_max
) {
1856 error(ERR_NONFATAL
, "minimum parameter count exceeds maximum");
1860 if (tline
&& tok_is_(tline
->next
, "+")) {
1861 tline
= tline
->next
;
1864 if (tline
&& tok_type_(tline
->next
, TOK_ID
) &&
1865 !nasm_stricmp(tline
->next
->text
, ".nolist")) {
1866 tline
= tline
->next
;
1871 * Handle default parameters.
1873 if (tline
&& tline
->next
) {
1874 def
->dlist
= tline
->next
;
1876 count_mmac_params(def
->dlist
, &def
->ndefs
, &def
->defaults
);
1879 def
->defaults
= NULL
;
1881 def
->expansion
= NULL
;
1884 def
->ndefs
> def
->nparam_max
- def
->nparam_min
&&
1886 error(ERR_WARNING
| ERR_WARN_MDP
, "too many default macro parameters");
1893 * Decode a size directive
1895 static int parse_size(const char *str
) {
1896 static const char *size_names
[] =
1897 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
1898 static const int sizes
[] =
1899 { 0, 1, 4, 16, 8, 10, 2, 32 };
1901 return sizes
[bsii(str
, size_names
, elements(size_names
))+1];
1905 * find and process preprocessor directive in passed line
1906 * Find out if a line contains a preprocessor directive, and deal
1909 * If a directive _is_ found, it is the responsibility of this routine
1910 * (and not the caller) to free_tlist() the line.
1912 * @param tline a pointer to the current tokeninzed line linked list
1913 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
1916 static int do_directive(Token
* tline
)
1918 enum preproc_token i
;
1926 char *p
, *pp
, *mname
;
1930 MMacro
*mmac
, **mmhead
;
1931 Token
*t
, *tt
, *param_start
, *macro_start
, *last
, **tptr
, *origline
;
1933 struct tokenval tokval
;
1935 MMacro
*tmp_defining
; /* Used when manipulating rep_nest */
1942 if (!tline
|| !tok_type_(tline
, TOK_PREPROC_ID
) ||
1943 (tline
->text
[1] == '%' || tline
->text
[1] == '$'
1944 || tline
->text
[1] == '!'))
1945 return NO_DIRECTIVE_FOUND
;
1947 i
= pp_token_hash(tline
->text
);
1950 * If we're in a non-emitting branch of a condition construct,
1951 * or walking to the end of an already terminated %rep block,
1952 * we should ignore all directives except for condition
1955 if (((istk
->conds
&& !emitting(istk
->conds
->state
)) ||
1956 (istk
->mstk
&& !istk
->mstk
->in_progress
)) && !is_condition(i
)) {
1957 return NO_DIRECTIVE_FOUND
;
1961 * If we're defining a macro or reading a %rep block, we should
1962 * ignore all directives except for %macro/%imacro (which nest),
1963 * %endm/%endmacro, and (only if we're in a %rep block) %endrep.
1964 * If we're in a %rep block, another %rep nests, so should be let through.
1966 if (defining
&& i
!= PP_MACRO
&& i
!= PP_IMACRO
&&
1967 i
!= PP_ENDMACRO
&& i
!= PP_ENDM
&&
1968 (defining
->name
|| (i
!= PP_ENDREP
&& i
!= PP_REP
))) {
1969 return NO_DIRECTIVE_FOUND
;
1973 if (i
== PP_MACRO
|| i
== PP_IMACRO
) {
1975 return NO_DIRECTIVE_FOUND
;
1976 } else if (nested_mac_count
> 0) {
1977 if (i
== PP_ENDMACRO
) {
1979 return NO_DIRECTIVE_FOUND
;
1982 if (!defining
->name
) {
1985 return NO_DIRECTIVE_FOUND
;
1986 } else if (nested_rep_count
> 0) {
1987 if (i
== PP_ENDREP
) {
1989 return NO_DIRECTIVE_FOUND
;
1997 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
1999 return NO_DIRECTIVE_FOUND
; /* didn't get it */
2002 /* Directive to tell NASM what the default stack size is. The
2003 * default is for a 16-bit stack, and this can be overriden with
2005 * the following form:
2007 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2009 tline
= tline
->next
;
2010 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2011 tline
= tline
->next
;
2012 if (!tline
|| tline
->type
!= TOK_ID
) {
2013 error(ERR_NONFATAL
, "`%%stacksize' missing size parameter");
2014 free_tlist(origline
);
2015 return DIRECTIVE_FOUND
;
2017 if (nasm_stricmp(tline
->text
, "flat") == 0) {
2018 /* All subsequent ARG directives are for a 32-bit stack */
2020 StackPointer
= "ebp";
2023 } else if (nasm_stricmp(tline
->text
, "flat64") == 0) {
2024 /* All subsequent ARG directives are for a 64-bit stack */
2026 StackPointer
= "rbp";
2029 } else if (nasm_stricmp(tline
->text
, "large") == 0) {
2030 /* All subsequent ARG directives are for a 16-bit stack,
2031 * far function call.
2034 StackPointer
= "bp";
2037 } else if (nasm_stricmp(tline
->text
, "small") == 0) {
2038 /* All subsequent ARG directives are for a 16-bit stack,
2039 * far function call. We don't support near functions.
2042 StackPointer
= "bp";
2046 error(ERR_NONFATAL
, "`%%stacksize' invalid size type");
2047 free_tlist(origline
);
2048 return DIRECTIVE_FOUND
;
2050 free_tlist(origline
);
2051 return DIRECTIVE_FOUND
;
2054 /* TASM like ARG directive to define arguments to functions, in
2055 * the following form:
2057 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2061 char *arg
, directive
[256];
2062 int size
= StackSize
;
2064 /* Find the argument name */
2065 tline
= tline
->next
;
2066 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2067 tline
= tline
->next
;
2068 if (!tline
|| tline
->type
!= TOK_ID
) {
2069 error(ERR_NONFATAL
, "`%%arg' missing argument parameter");
2070 free_tlist(origline
);
2071 return DIRECTIVE_FOUND
;
2075 /* Find the argument size type */
2076 tline
= tline
->next
;
2077 if (!tline
|| tline
->type
!= TOK_OTHER
2078 || tline
->text
[0] != ':') {
2080 "Syntax error processing `%%arg' directive");
2081 free_tlist(origline
);
2082 return DIRECTIVE_FOUND
;
2084 tline
= tline
->next
;
2085 if (!tline
|| tline
->type
!= TOK_ID
) {
2086 error(ERR_NONFATAL
, "`%%arg' missing size type parameter");
2087 free_tlist(origline
);
2088 return DIRECTIVE_FOUND
;
2091 /* Allow macro expansion of type parameter */
2092 tt
= tokenize(tline
->text
);
2093 tt
= expand_smacro(tt
);
2094 size
= parse_size(tt
->text
);
2097 "Invalid size type for `%%arg' missing directive");
2099 free_tlist(origline
);
2100 return DIRECTIVE_FOUND
;
2104 /* Round up to even stack slots */
2105 size
= (size
+StackSize
-1) & ~(StackSize
-1);
2107 /* Now define the macro for the argument */
2108 snprintf(directive
, sizeof(directive
), "%%define %s (%s+%d)",
2109 arg
, StackPointer
, offset
);
2110 do_directive(tokenize(directive
));
2113 /* Move to the next argument in the list */
2114 tline
= tline
->next
;
2115 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2116 tline
= tline
->next
;
2117 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2119 free_tlist(origline
);
2120 return DIRECTIVE_FOUND
;
2123 /* TASM like LOCAL directive to define local variables for a
2124 * function, in the following form:
2126 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2128 * The '= LocalSize' at the end is ignored by NASM, but is
2129 * required by TASM to define the local parameter size (and used
2130 * by the TASM macro package).
2132 offset
= LocalOffset
;
2134 char *local
, directive
[256];
2135 int size
= StackSize
;
2137 /* Find the argument name */
2138 tline
= tline
->next
;
2139 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2140 tline
= tline
->next
;
2141 if (!tline
|| tline
->type
!= TOK_ID
) {
2143 "`%%local' missing argument parameter");
2144 free_tlist(origline
);
2145 return DIRECTIVE_FOUND
;
2147 local
= tline
->text
;
2149 /* Find the argument size type */
2150 tline
= tline
->next
;
2151 if (!tline
|| tline
->type
!= TOK_OTHER
2152 || tline
->text
[0] != ':') {
2154 "Syntax error processing `%%local' directive");
2155 free_tlist(origline
);
2156 return DIRECTIVE_FOUND
;
2158 tline
= tline
->next
;
2159 if (!tline
|| tline
->type
!= TOK_ID
) {
2161 "`%%local' missing size type parameter");
2162 free_tlist(origline
);
2163 return DIRECTIVE_FOUND
;
2166 /* Allow macro expansion of type parameter */
2167 tt
= tokenize(tline
->text
);
2168 tt
= expand_smacro(tt
);
2169 size
= parse_size(tt
->text
);
2172 "Invalid size type for `%%local' missing directive");
2174 free_tlist(origline
);
2175 return DIRECTIVE_FOUND
;
2179 /* Round up to even stack slots */
2180 size
= (size
+StackSize
-1) & ~(StackSize
-1);
2182 offset
+= size
; /* Negative offset, increment before */
2184 /* Now define the macro for the argument */
2185 snprintf(directive
, sizeof(directive
), "%%define %s (%s-%d)",
2186 local
, StackPointer
, offset
);
2187 do_directive(tokenize(directive
));
2189 /* Now define the assign to setup the enter_c macro correctly */
2190 snprintf(directive
, sizeof(directive
),
2191 "%%assign %%$localsize %%$localsize+%d", size
);
2192 do_directive(tokenize(directive
));
2194 /* Move to the next argument in the list */
2195 tline
= tline
->next
;
2196 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2197 tline
= tline
->next
;
2198 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2199 LocalOffset
= offset
;
2200 free_tlist(origline
);
2201 return DIRECTIVE_FOUND
;
2205 error(ERR_WARNING
, "trailing garbage after `%%clear' ignored");
2208 free_tlist(origline
);
2209 return DIRECTIVE_FOUND
;
2212 t
= tline
->next
= expand_smacro(tline
->next
);
2214 if (!t
|| (t
->type
!= TOK_STRING
&&
2215 t
->type
!= TOK_INTERNAL_STRING
)) {
2216 error(ERR_NONFATAL
, "`%%depend' expects a file name");
2217 free_tlist(origline
);
2218 return DIRECTIVE_FOUND
; /* but we did _something_ */
2222 "trailing garbage after `%%depend' ignored");
2224 if (t
->type
!= TOK_INTERNAL_STRING
)
2225 nasm_unquote(p
, NULL
);
2226 if (dephead
&& !in_list(*dephead
, p
)) {
2227 StrList
*sl
= nasm_malloc(strlen(p
)+1+sizeof sl
->next
);
2231 deptail
= &sl
->next
;
2233 free_tlist(origline
);
2234 return DIRECTIVE_FOUND
;
2237 t
= tline
->next
= expand_smacro(tline
->next
);
2240 if (!t
|| (t
->type
!= TOK_STRING
&&
2241 t
->type
!= TOK_INTERNAL_STRING
)) {
2242 error(ERR_NONFATAL
, "`%%include' expects a file name");
2243 free_tlist(origline
);
2244 return DIRECTIVE_FOUND
; /* but we did _something_ */
2248 "trailing garbage after `%%include' ignored");
2250 if (t
->type
!= TOK_INTERNAL_STRING
)
2251 nasm_unquote(p
, NULL
);
2252 inc
= nasm_malloc(sizeof(Include
));
2255 inc
->fp
= inc_fopen(p
, dephead
, &deptail
, pass
== 0);
2257 /* -MG given but file not found */
2260 inc
->fname
= src_set_fname(nasm_strdup(p
));
2261 inc
->lineno
= src_set_linnum(0);
2263 inc
->expansion
= NULL
;
2266 list
->uplevel(LIST_INCLUDE
);
2268 free_tlist(origline
);
2269 return DIRECTIVE_FOUND
;
2273 static macros_t
*use_pkg
;
2274 const char *pkg_macro
;
2276 t
= tline
->next
= expand_smacro(tline
->next
);
2279 if (!t
|| (t
->type
!= TOK_STRING
&&
2280 t
->type
!= TOK_INTERNAL_STRING
&&
2281 t
->type
!= TOK_ID
)) {
2282 error(ERR_NONFATAL
, "`%%use' expects a package name");
2283 free_tlist(origline
);
2284 return DIRECTIVE_FOUND
; /* but we did _something_ */
2288 "trailing garbage after `%%use' ignored");
2289 if (t
->type
== TOK_STRING
)
2290 nasm_unquote(t
->text
, NULL
);
2291 use_pkg
= nasm_stdmac_find_package(t
->text
);
2293 error(ERR_NONFATAL
, "unknown `%%use' package: %s", t
->text
);
2294 /* The first string will be <%define>__USE_*__ */
2295 pkg_macro
= (char *)use_pkg
+ 1;
2296 if (!smacro_defined(NULL
, pkg_macro
, 0, NULL
, true)) {
2297 /* Not already included, go ahead and include it */
2298 stdmacpos
= use_pkg
;
2300 free_tlist(origline
);
2301 return DIRECTIVE_FOUND
;
2304 tline
= tline
->next
;
2306 tline
= expand_id(tline
);
2308 if (!tok_type_(tline
, TOK_ID
)) {
2309 error(ERR_NONFATAL
, "`%%push' expects a context identifier");
2310 free_tlist(origline
);
2311 return DIRECTIVE_FOUND
; /* but we did _something_ */
2314 error(ERR_WARNING
, "trailing garbage after `%%push' ignored");
2315 p
= nasm_strdup(tline
->text
);
2317 p
= NULL
; /* Anonymous context */
2319 ctx
= nasm_malloc(sizeof(Context
));
2321 hash_init(&ctx
->localmac
, HASH_SMALL
);
2323 ctx
->number
= unique
++;
2325 free_tlist(origline
);
2326 return DIRECTIVE_FOUND
;
2329 tline
= tline
->next
;
2331 tline
= expand_id(tline
);
2333 if (!tok_type_(tline
, TOK_ID
)) {
2334 error(ERR_NONFATAL
, "`%%repl' expects a context identifier");
2335 free_tlist(origline
);
2336 return DIRECTIVE_FOUND
; /* but we did _something_ */
2339 error(ERR_WARNING
, "trailing garbage after `%%repl' ignored");
2340 p
= nasm_strdup(tline
->text
);
2345 error(ERR_NONFATAL
, "`%%repl': context stack is empty");
2347 nasm_free(cstk
->name
);
2350 free_tlist(origline
);
2351 return DIRECTIVE_FOUND
;
2355 error(ERR_WARNING
, "trailing garbage after `%%pop' ignored");
2357 error(ERR_NONFATAL
, "`%%pop': context stack is already empty");
2360 free_tlist(origline
);
2361 return DIRECTIVE_FOUND
;
2366 int severity
= (i
== PP_ERROR
)
2367 ? ERR_NONFATAL
|ERR_NO_SEVERITY
2368 : ERR_WARNING
|ERR_NO_SEVERITY
;
2370 tline
->next
= expand_smacro(tline
->next
);
2371 tline
= tline
->next
;
2373 t
= tline
? tline
->next
: NULL
;
2375 if (tok_type_(tline
, TOK_STRING
) && !t
) {
2376 /* The line contains only a quoted string */
2378 nasm_unquote(p
, NULL
);
2379 error(severity
, "%s: %s", pp_directives
[i
], p
);
2381 /* Not a quoted string, or more than a quoted string */
2382 p
= detoken(tline
, false);
2383 error(severity
, "%s: %s", pp_directives
[i
], p
);
2386 free_tlist(origline
);
2387 return DIRECTIVE_FOUND
;
2391 if (istk
->conds
&& !emitting(istk
->conds
->state
))
2394 j
= if_condition(tline
->next
, i
);
2395 tline
->next
= NULL
; /* it got freed */
2396 j
= j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2398 cond
= nasm_malloc(sizeof(Cond
));
2399 cond
->next
= istk
->conds
;
2402 free_tlist(origline
);
2403 return DIRECTIVE_FOUND
;
2407 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2408 if (emitting(istk
->conds
->state
)
2409 || istk
->conds
->state
== COND_NEVER
)
2410 istk
->conds
->state
= COND_NEVER
;
2413 * IMPORTANT: In the case of %if, we will already have
2414 * called expand_mmac_params(); however, if we're
2415 * processing an %elif we must have been in a
2416 * non-emitting mode, which would have inhibited
2417 * the normal invocation of expand_mmac_params(). Therefore,
2418 * we have to do it explicitly here.
2420 j
= if_condition(expand_mmac_params(tline
->next
), i
);
2421 tline
->next
= NULL
; /* it got freed */
2422 istk
->conds
->state
=
2423 j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2425 free_tlist(origline
);
2426 return DIRECTIVE_FOUND
;
2430 error(ERR_WARNING
, "trailing garbage after `%%else' ignored");
2432 error(ERR_FATAL
, "`%%else': no matching `%%if'");
2433 if (emitting(istk
->conds
->state
)
2434 || istk
->conds
->state
== COND_NEVER
)
2435 istk
->conds
->state
= COND_ELSE_FALSE
;
2437 istk
->conds
->state
= COND_ELSE_TRUE
;
2438 free_tlist(origline
);
2439 return DIRECTIVE_FOUND
;
2443 error(ERR_WARNING
, "trailing garbage after `%%endif' ignored");
2445 error(ERR_FATAL
, "`%%endif': no matching `%%if'");
2447 istk
->conds
= cond
->next
;
2449 free_tlist(origline
);
2450 return DIRECTIVE_FOUND
;
2456 "`%%%smacro': already defining a macro",
2457 (i
== PP_IMACRO
? "i" : ""));
2458 return DIRECTIVE_FOUND
;
2460 defining
= nasm_malloc(sizeof(MMacro
));
2461 defining
->casesense
= (i
== PP_MACRO
);
2462 if (!parse_mmacro_spec(tline
, defining
, pp_directives
[i
])) {
2463 nasm_free(defining
);
2465 return DIRECTIVE_FOUND
;
2468 mmac
= (MMacro
*) hash_findix(&mmacros
, defining
->name
);
2470 if (!strcmp(mmac
->name
, defining
->name
) &&
2471 (mmac
->nparam_min
<= defining
->nparam_max
2473 && (defining
->nparam_min
<= mmac
->nparam_max
2476 "redefining multi-line macro `%s'", defining
->name
);
2477 return DIRECTIVE_FOUND
;
2481 free_tlist(origline
);
2482 return DIRECTIVE_FOUND
;
2486 if (! (defining
&& defining
->name
)) {
2487 error(ERR_NONFATAL
, "`%s': not defining a macro", tline
->text
);
2488 return DIRECTIVE_FOUND
;
2490 mmhead
= (MMacro
**) hash_findi_add(&mmacros
, defining
->name
);
2491 defining
->next
= *mmhead
;
2494 free_tlist(origline
);
2495 return DIRECTIVE_FOUND
;
2503 spec
.casesense
= (i
== PP_UNMACRO
);
2504 if (!parse_mmacro_spec(tline
, &spec
, pp_directives
[i
])) {
2505 return DIRECTIVE_FOUND
;
2507 mmac_p
= (MMacro
**) hash_findi(&mmacros
, spec
.name
, NULL
);
2508 while (mmac_p
&& *mmac_p
) {
2510 if (mmac
->casesense
== spec
.casesense
&&
2511 !mstrcmp(mmac
->name
, spec
.name
, spec
.casesense
) &&
2512 mmac
->nparam_min
== spec
.nparam_min
&&
2513 mmac
->nparam_max
== spec
.nparam_max
&&
2514 mmac
->plus
== spec
.plus
) {
2515 *mmac_p
= mmac
->next
;
2518 mmac_p
= &mmac
->next
;
2521 free_tlist(origline
);
2522 free_tlist(spec
.dlist
);
2523 return DIRECTIVE_FOUND
;
2527 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
2528 tline
= tline
->next
;
2529 if (tline
->next
== NULL
) {
2530 free_tlist(origline
);
2531 error(ERR_NONFATAL
, "`%%rotate' missing rotate count");
2532 return DIRECTIVE_FOUND
;
2534 t
= expand_smacro(tline
->next
);
2536 free_tlist(origline
);
2539 tokval
.t_type
= TOKEN_INVALID
;
2541 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2544 return DIRECTIVE_FOUND
;
2547 "trailing garbage after expression ignored");
2548 if (!is_simple(evalresult
)) {
2549 error(ERR_NONFATAL
, "non-constant value given to `%%rotate'");
2550 return DIRECTIVE_FOUND
;
2553 while (mmac
&& !mmac
->name
) /* avoid mistaking %reps for macros */
2554 mmac
= mmac
->next_active
;
2556 error(ERR_NONFATAL
, "`%%rotate' invoked outside a macro call");
2557 } else if (mmac
->nparam
== 0) {
2559 "`%%rotate' invoked within macro without parameters");
2561 int rotate
= mmac
->rotate
+ reloc_value(evalresult
);
2563 rotate
%= (int)mmac
->nparam
;
2565 rotate
+= mmac
->nparam
;
2567 mmac
->rotate
= rotate
;
2569 return DIRECTIVE_FOUND
;
2574 tline
= tline
->next
;
2575 } while (tok_type_(tline
, TOK_WHITESPACE
));
2577 if (tok_type_(tline
, TOK_ID
) &&
2578 nasm_stricmp(tline
->text
, ".nolist") == 0) {
2581 tline
= tline
->next
;
2582 } while (tok_type_(tline
, TOK_WHITESPACE
));
2586 t
= expand_smacro(tline
);
2588 tokval
.t_type
= TOKEN_INVALID
;
2590 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2592 free_tlist(origline
);
2593 return DIRECTIVE_FOUND
;
2597 "trailing garbage after expression ignored");
2598 if (!is_simple(evalresult
)) {
2599 error(ERR_NONFATAL
, "non-constant value given to `%%rep'");
2600 return DIRECTIVE_FOUND
;
2602 count
= reloc_value(evalresult
) + 1;
2604 error(ERR_NONFATAL
, "`%%rep' expects a repeat count");
2607 free_tlist(origline
);
2609 tmp_defining
= defining
;
2610 defining
= nasm_malloc(sizeof(MMacro
));
2611 defining
->name
= NULL
; /* flags this macro as a %rep block */
2612 defining
->casesense
= false;
2613 defining
->plus
= false;
2614 defining
->nolist
= nolist
;
2615 defining
->in_progress
= count
;
2616 defining
->nparam_min
= defining
->nparam_max
= 0;
2617 defining
->defaults
= NULL
;
2618 defining
->dlist
= NULL
;
2619 defining
->expansion
= NULL
;
2620 defining
->next_active
= istk
->mstk
;
2621 defining
->rep_nest
= tmp_defining
;
2622 return DIRECTIVE_FOUND
;
2625 if (!defining
|| defining
->name
) {
2626 error(ERR_NONFATAL
, "`%%endrep': no matching `%%rep'");
2627 return DIRECTIVE_FOUND
;
2631 * Now we have a "macro" defined - although it has no name
2632 * and we won't be entering it in the hash tables - we must
2633 * push a macro-end marker for it on to istk->expansion.
2634 * After that, it will take care of propagating itself (a
2635 * macro-end marker line for a macro which is really a %rep
2636 * block will cause the macro to be re-expanded, complete
2637 * with another macro-end marker to ensure the process
2638 * continues) until the whole expansion is forcibly removed
2639 * from istk->expansion by a %exitrep.
2641 l
= nasm_malloc(sizeof(Line
));
2642 l
->next
= istk
->expansion
;
2643 l
->finishes
= defining
;
2645 istk
->expansion
= l
;
2647 istk
->mstk
= defining
;
2649 list
->uplevel(defining
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
2650 tmp_defining
= defining
;
2651 defining
= defining
->rep_nest
;
2652 free_tlist(origline
);
2653 return DIRECTIVE_FOUND
;
2657 * We must search along istk->expansion until we hit a
2658 * macro-end marker for a macro with no name. Then we set
2659 * its `in_progress' flag to 0.
2661 for (l
= istk
->expansion
; l
; l
= l
->next
)
2662 if (l
->finishes
&& !l
->finishes
->name
)
2666 l
->finishes
->in_progress
= 1;
2668 error(ERR_NONFATAL
, "`%%exitrep' not within `%%rep' block");
2669 free_tlist(origline
);
2670 return DIRECTIVE_FOUND
;
2676 casesense
= (i
== PP_DEFINE
|| i
== PP_XDEFINE
);
2678 tline
= tline
->next
;
2680 tline
= expand_id(tline
);
2681 if (!tline
|| (tline
->type
!= TOK_ID
&&
2682 (tline
->type
!= TOK_PREPROC_ID
||
2683 tline
->text
[1] != '$'))) {
2684 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
2686 free_tlist(origline
);
2687 return DIRECTIVE_FOUND
;
2690 ctx
= get_ctx(tline
->text
, false);
2692 mname
= tline
->text
;
2694 param_start
= tline
= tline
->next
;
2697 /* Expand the macro definition now for %xdefine and %ixdefine */
2698 if ((i
== PP_XDEFINE
) || (i
== PP_IXDEFINE
))
2699 tline
= expand_smacro(tline
);
2701 if (tok_is_(tline
, "(")) {
2703 * This macro has parameters.
2706 tline
= tline
->next
;
2710 error(ERR_NONFATAL
, "parameter identifier expected");
2711 free_tlist(origline
);
2712 return DIRECTIVE_FOUND
;
2714 if (tline
->type
!= TOK_ID
) {
2716 "`%s': parameter identifier expected",
2718 free_tlist(origline
);
2719 return DIRECTIVE_FOUND
;
2721 tline
->type
= TOK_SMAC_PARAM
+ nparam
++;
2722 tline
= tline
->next
;
2724 if (tok_is_(tline
, ",")) {
2725 tline
= tline
->next
;
2727 if (!tok_is_(tline
, ")")) {
2729 "`)' expected to terminate macro template");
2730 free_tlist(origline
);
2731 return DIRECTIVE_FOUND
;
2737 tline
= tline
->next
;
2739 if (tok_type_(tline
, TOK_WHITESPACE
))
2740 last
= tline
, tline
= tline
->next
;
2745 if (t
->type
== TOK_ID
) {
2746 for (tt
= param_start
; tt
; tt
= tt
->next
)
2747 if (tt
->type
>= TOK_SMAC_PARAM
&&
2748 !strcmp(tt
->text
, t
->text
))
2752 t
->next
= macro_start
;
2757 * Good. We now have a macro name, a parameter count, and a
2758 * token list (in reverse order) for an expansion. We ought
2759 * to be OK just to create an SMacro, store it, and let
2760 * free_tlist have the rest of the line (which we have
2761 * carefully re-terminated after chopping off the expansion
2764 define_smacro(ctx
, mname
, casesense
, nparam
, macro_start
);
2765 free_tlist(origline
);
2766 return DIRECTIVE_FOUND
;
2769 tline
= tline
->next
;
2771 tline
= expand_id(tline
);
2772 if (!tline
|| (tline
->type
!= TOK_ID
&&
2773 (tline
->type
!= TOK_PREPROC_ID
||
2774 tline
->text
[1] != '$'))) {
2775 error(ERR_NONFATAL
, "`%%undef' expects a macro identifier");
2776 free_tlist(origline
);
2777 return DIRECTIVE_FOUND
;
2781 "trailing garbage after macro name ignored");
2784 /* Find the context that symbol belongs to */
2785 ctx
= get_ctx(tline
->text
, false);
2786 undef_smacro(ctx
, tline
->text
);
2787 free_tlist(origline
);
2788 return DIRECTIVE_FOUND
;
2792 casesense
= (i
== PP_DEFSTR
);
2794 tline
= tline
->next
;
2796 tline
= expand_id(tline
);
2797 if (!tline
|| (tline
->type
!= TOK_ID
&&
2798 (tline
->type
!= TOK_PREPROC_ID
||
2799 tline
->text
[1] != '$'))) {
2800 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
2802 free_tlist(origline
);
2803 return DIRECTIVE_FOUND
;
2806 ctx
= get_ctx(tline
->text
, false);
2808 mname
= tline
->text
;
2810 tline
= expand_smacro(tline
->next
);
2813 while (tok_type_(tline
, TOK_WHITESPACE
))
2814 tline
= delete_Token(tline
);
2816 p
= detoken(tline
, false);
2817 macro_start
= nasm_malloc(sizeof(*macro_start
));
2818 macro_start
->next
= NULL
;
2819 macro_start
->text
= nasm_quote(p
, strlen(p
));
2820 macro_start
->type
= TOK_STRING
;
2821 macro_start
->a
.mac
= NULL
;
2825 * We now have a macro name, an implicit parameter count of
2826 * zero, and a string token to use as an expansion. Create
2827 * and store an SMacro.
2829 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2830 free_tlist(origline
);
2831 return DIRECTIVE_FOUND
;
2836 StrList
*xsl
= NULL
;
2837 StrList
**xst
= &xsl
;
2841 tline
= tline
->next
;
2843 tline
= expand_id(tline
);
2844 if (!tline
|| (tline
->type
!= TOK_ID
&&
2845 (tline
->type
!= TOK_PREPROC_ID
||
2846 tline
->text
[1] != '$'))) {
2848 "`%%pathsearch' expects a macro identifier as first parameter");
2849 free_tlist(origline
);
2850 return DIRECTIVE_FOUND
;
2852 ctx
= get_ctx(tline
->text
, false);
2854 mname
= tline
->text
;
2856 tline
= expand_smacro(tline
->next
);
2860 while (tok_type_(t
, TOK_WHITESPACE
))
2863 if (!t
|| (t
->type
!= TOK_STRING
&&
2864 t
->type
!= TOK_INTERNAL_STRING
)) {
2865 error(ERR_NONFATAL
, "`%%pathsearch' expects a file name");
2867 free_tlist(origline
);
2868 return DIRECTIVE_FOUND
; /* but we did _something_ */
2872 "trailing garbage after `%%pathsearch' ignored");
2874 if (t
->type
!= TOK_INTERNAL_STRING
)
2875 nasm_unquote(p
, NULL
);
2877 fp
= inc_fopen(p
, &xsl
, &xst
, true);
2880 fclose(fp
); /* Don't actually care about the file */
2882 macro_start
= nasm_malloc(sizeof(*macro_start
));
2883 macro_start
->next
= NULL
;
2884 macro_start
->text
= nasm_quote(p
, strlen(p
));
2885 macro_start
->type
= TOK_STRING
;
2886 macro_start
->a
.mac
= NULL
;
2891 * We now have a macro name, an implicit parameter count of
2892 * zero, and a string token to use as an expansion. Create
2893 * and store an SMacro.
2895 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2897 free_tlist(origline
);
2898 return DIRECTIVE_FOUND
;
2904 tline
= tline
->next
;
2906 tline
= expand_id(tline
);
2907 if (!tline
|| (tline
->type
!= TOK_ID
&&
2908 (tline
->type
!= TOK_PREPROC_ID
||
2909 tline
->text
[1] != '$'))) {
2911 "`%%strlen' expects a macro identifier as first parameter");
2912 free_tlist(origline
);
2913 return DIRECTIVE_FOUND
;
2915 ctx
= get_ctx(tline
->text
, false);
2917 mname
= tline
->text
;
2919 tline
= expand_smacro(tline
->next
);
2923 while (tok_type_(t
, TOK_WHITESPACE
))
2925 /* t should now point to the string */
2926 if (t
->type
!= TOK_STRING
) {
2928 "`%%strlen` requires string as second parameter");
2930 free_tlist(origline
);
2931 return DIRECTIVE_FOUND
;
2934 macro_start
= nasm_malloc(sizeof(*macro_start
));
2935 macro_start
->next
= NULL
;
2936 make_tok_num(macro_start
, nasm_unquote(t
->text
, NULL
));
2937 macro_start
->a
.mac
= NULL
;
2940 * We now have a macro name, an implicit parameter count of
2941 * zero, and a numeric token to use as an expansion. Create
2942 * and store an SMacro.
2944 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2946 free_tlist(origline
);
2947 return DIRECTIVE_FOUND
;
2952 tline
= tline
->next
;
2954 tline
= expand_id(tline
);
2955 if (!tline
|| (tline
->type
!= TOK_ID
&&
2956 (tline
->type
!= TOK_PREPROC_ID
||
2957 tline
->text
[1] != '$'))) {
2959 "`%%strcat' expects a macro identifier as first parameter");
2960 free_tlist(origline
);
2961 return DIRECTIVE_FOUND
;
2963 ctx
= get_ctx(tline
->text
, false);
2965 mname
= tline
->text
;
2967 tline
= expand_smacro(tline
->next
);
2971 for (t
= tline
; t
; t
= t
->next
) {
2973 case TOK_WHITESPACE
:
2976 len
+= t
->a
.len
= nasm_unquote(t
->text
, NULL
);
2979 if (!strcmp(t
->text
, ",")) /* permit comma separators */
2981 /* else fall through */
2984 "non-string passed to `%%strcat' (%d)", t
->type
);
2986 free_tlist(origline
);
2987 return DIRECTIVE_FOUND
;
2991 p
= pp
= nasm_malloc(len
);
2993 for (t
= tline
; t
; t
= t
->next
) {
2994 if (t
->type
== TOK_STRING
) {
2995 memcpy(p
, t
->text
, t
->a
.len
);
3001 * We now have a macro name, an implicit parameter count of
3002 * zero, and a numeric token to use as an expansion. Create
3003 * and store an SMacro.
3005 macro_start
= new_Token(NULL
, TOK_STRING
, NULL
, 0);
3006 macro_start
->text
= nasm_quote(pp
, len
);
3008 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3010 free_tlist(origline
);
3011 return DIRECTIVE_FOUND
;
3020 tline
= tline
->next
;
3022 tline
= expand_id(tline
);
3023 if (!tline
|| (tline
->type
!= TOK_ID
&&
3024 (tline
->type
!= TOK_PREPROC_ID
||
3025 tline
->text
[1] != '$'))) {
3027 "`%%substr' expects a macro identifier as first parameter");
3028 free_tlist(origline
);
3029 return DIRECTIVE_FOUND
;
3031 ctx
= get_ctx(tline
->text
, false);
3033 mname
= tline
->text
;
3035 tline
= expand_smacro(tline
->next
);
3039 while (tok_type_(t
, TOK_WHITESPACE
))
3042 /* t should now point to the string */
3043 if (t
->type
!= TOK_STRING
) {
3045 "`%%substr` requires string as second parameter");
3047 free_tlist(origline
);
3048 return DIRECTIVE_FOUND
;
3053 tokval
.t_type
= TOKEN_INVALID
;
3054 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3058 free_tlist(origline
);
3059 return DIRECTIVE_FOUND
;
3060 } else if (!is_simple(evalresult
)) {
3061 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3063 free_tlist(origline
);
3064 return DIRECTIVE_FOUND
;
3066 a1
= evalresult
->value
-1;
3068 while (tok_type_(tt
, TOK_WHITESPACE
))
3071 a2
= 1; /* Backwards compatibility: one character */
3073 tokval
.t_type
= TOKEN_INVALID
;
3074 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3078 free_tlist(origline
);
3079 return DIRECTIVE_FOUND
;
3080 } else if (!is_simple(evalresult
)) {
3081 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3083 free_tlist(origline
);
3084 return DIRECTIVE_FOUND
;
3086 a2
= evalresult
->value
;
3089 len
= nasm_unquote(t
->text
, NULL
);
3092 if (a1
+a2
> (int64_t)len
)
3095 macro_start
= nasm_malloc(sizeof(*macro_start
));
3096 macro_start
->next
= NULL
;
3097 macro_start
->text
= nasm_quote((a1
< 0) ? "" : t
->text
+a1
, a2
);
3098 macro_start
->type
= TOK_STRING
;
3099 macro_start
->a
.mac
= NULL
;
3102 * We now have a macro name, an implicit parameter count of
3103 * zero, and a numeric token to use as an expansion. Create
3104 * and store an SMacro.
3106 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3108 free_tlist(origline
);
3109 return DIRECTIVE_FOUND
;
3114 casesense
= (i
== PP_ASSIGN
);
3116 tline
= tline
->next
;
3118 tline
= expand_id(tline
);
3119 if (!tline
|| (tline
->type
!= TOK_ID
&&
3120 (tline
->type
!= TOK_PREPROC_ID
||
3121 tline
->text
[1] != '$'))) {
3123 "`%%%sassign' expects a macro identifier",
3124 (i
== PP_IASSIGN
? "i" : ""));
3125 free_tlist(origline
);
3126 return DIRECTIVE_FOUND
;
3128 ctx
= get_ctx(tline
->text
, false);
3130 mname
= tline
->text
;
3132 tline
= expand_smacro(tline
->next
);
3137 tokval
.t_type
= TOKEN_INVALID
;
3139 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3142 free_tlist(origline
);
3143 return DIRECTIVE_FOUND
;
3148 "trailing garbage after expression ignored");
3150 if (!is_simple(evalresult
)) {
3152 "non-constant value given to `%%%sassign'",
3153 (i
== PP_IASSIGN
? "i" : ""));
3154 free_tlist(origline
);
3155 return DIRECTIVE_FOUND
;
3158 macro_start
= nasm_malloc(sizeof(*macro_start
));
3159 macro_start
->next
= NULL
;
3160 make_tok_num(macro_start
, reloc_value(evalresult
));
3161 macro_start
->a
.mac
= NULL
;
3164 * We now have a macro name, an implicit parameter count of
3165 * zero, and a numeric token to use as an expansion. Create
3166 * and store an SMacro.
3168 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3169 free_tlist(origline
);
3170 return DIRECTIVE_FOUND
;
3174 * Syntax is `%line nnn[+mmm] [filename]'
3176 tline
= tline
->next
;
3178 if (!tok_type_(tline
, TOK_NUMBER
)) {
3179 error(ERR_NONFATAL
, "`%%line' expects line number");
3180 free_tlist(origline
);
3181 return DIRECTIVE_FOUND
;
3183 k
= readnum(tline
->text
, &err
);
3185 tline
= tline
->next
;
3186 if (tok_is_(tline
, "+")) {
3187 tline
= tline
->next
;
3188 if (!tok_type_(tline
, TOK_NUMBER
)) {
3189 error(ERR_NONFATAL
, "`%%line' expects line increment");
3190 free_tlist(origline
);
3191 return DIRECTIVE_FOUND
;
3193 m
= readnum(tline
->text
, &err
);
3194 tline
= tline
->next
;
3200 nasm_free(src_set_fname(detoken(tline
, false)));
3202 free_tlist(origline
);
3203 return DIRECTIVE_FOUND
;
3207 "preprocessor directive `%s' not yet implemented",
3209 return DIRECTIVE_FOUND
;
3214 * Ensure that a macro parameter contains a condition code and
3215 * nothing else. Return the condition code index if so, or -1
3218 static int find_cc(Token
* t
)
3224 return -1; /* Probably a %+ without a space */
3227 if (t
->type
!= TOK_ID
)
3231 if (tt
&& (tt
->type
!= TOK_OTHER
|| strcmp(tt
->text
, ",")))
3235 j
= elements(conditions
);
3238 m
= nasm_stricmp(t
->text
, conditions
[k
]);
3254 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3255 * %-n) and MMacro-local identifiers (%%foo).
3257 static Token
*expand_mmac_params(Token
* tline
)
3259 Token
*t
, *tt
, **tail
, *thead
;
3265 if (tline
->type
== TOK_PREPROC_ID
&&
3266 (((tline
->text
[1] == '+' || tline
->text
[1] == '-')
3267 && tline
->text
[2]) || tline
->text
[1] == '%'
3268 || (tline
->text
[1] >= '0' && tline
->text
[1] <= '9'))) {
3270 int type
= 0, cc
; /* type = 0 to placate optimisers */
3277 tline
= tline
->next
;
3280 while (mac
&& !mac
->name
) /* avoid mistaking %reps for macros */
3281 mac
= mac
->next_active
;
3283 error(ERR_NONFATAL
, "`%s': not in a macro call", t
->text
);
3285 switch (t
->text
[1]) {
3287 * We have to make a substitution of one of the
3288 * forms %1, %-1, %+1, %%foo, %0.
3292 snprintf(tmpbuf
, sizeof(tmpbuf
), "%d", mac
->nparam
);
3293 text
= nasm_strdup(tmpbuf
);
3297 snprintf(tmpbuf
, sizeof(tmpbuf
), "..@%"PRIu64
".",
3299 text
= nasm_strcat(tmpbuf
, t
->text
+ 2);
3302 n
= atoi(t
->text
+ 2) - 1;
3303 if (n
>= mac
->nparam
)
3306 if (mac
->nparam
> 1)
3307 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3308 tt
= mac
->params
[n
];
3313 "macro parameter %d is not a condition code",
3318 if (inverse_ccs
[cc
] == -1) {
3320 "condition code `%s' is not invertible",
3325 nasm_strdup(conditions
[inverse_ccs
[cc
]]);
3329 n
= atoi(t
->text
+ 2) - 1;
3330 if (n
>= mac
->nparam
)
3333 if (mac
->nparam
> 1)
3334 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3335 tt
= mac
->params
[n
];
3340 "macro parameter %d is not a condition code",
3345 text
= nasm_strdup(conditions
[cc
]);
3349 n
= atoi(t
->text
+ 1) - 1;
3350 if (n
>= mac
->nparam
)
3353 if (mac
->nparam
> 1)
3354 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3355 tt
= mac
->params
[n
];
3358 for (i
= 0; i
< mac
->paramlen
[n
]; i
++) {
3359 *tail
= new_Token(NULL
, tt
->type
, tt
->text
, 0);
3360 tail
= &(*tail
)->next
;
3364 text
= NULL
; /* we've done it here */
3380 tline
= tline
->next
;
3387 for (; t
&& (tt
= t
->next
) != NULL
; t
= t
->next
)
3389 case TOK_WHITESPACE
:
3390 if (tt
->type
== TOK_WHITESPACE
) {
3391 t
->next
= delete_Token(tt
);
3395 if (tt
->type
== TOK_ID
|| tt
->type
== TOK_NUMBER
) {
3396 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3399 t
->next
= delete_Token(tt
);
3403 if (tt
->type
== TOK_NUMBER
) {
3404 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3407 t
->next
= delete_Token(tt
);
3418 * Expand all single-line macro calls made in the given line.
3419 * Return the expanded version of the line. The original is deemed
3420 * to be destroyed in the process. (In reality we'll just move
3421 * Tokens from input to output a lot of the time, rather than
3422 * actually bothering to destroy and replicate.)
3424 #define DEADMAN_LIMIT (1 << 20)
3426 static Token
*expand_smacro(Token
* tline
)
3428 Token
*t
, *tt
, *mstart
, **tail
, *thead
;
3429 struct hash_table
*smtbl
;
3430 SMacro
*head
= NULL
, *m
;
3433 unsigned int nparam
, sparam
;
3434 int brackets
, rescan
;
3435 Token
*org_tline
= tline
;
3438 int deadman
= DEADMAN_LIMIT
;
3441 * Trick: we should avoid changing the start token pointer since it can
3442 * be contained in "next" field of other token. Because of this
3443 * we allocate a copy of first token and work with it; at the end of
3444 * routine we copy it back
3448 new_Token(org_tline
->next
, org_tline
->type
, org_tline
->text
,
3450 tline
->a
.mac
= org_tline
->a
.mac
;
3451 nasm_free(org_tline
->text
);
3452 org_tline
->text
= NULL
;
3459 while (tline
) { /* main token loop */
3461 error(ERR_NONFATAL
, "interminable macro recursion");
3465 if ((mname
= tline
->text
)) {
3466 /* if this token is a local macro, look in local context */
3469 if (tline
->type
== TOK_ID
|| tline
->type
== TOK_PREPROC_ID
) {
3470 ctx
= get_ctx(mname
, true);
3472 smtbl
= &ctx
->localmac
;
3474 head
= (SMacro
*) hash_findix(smtbl
, mname
);
3477 * We've hit an identifier. As in is_mmacro below, we first
3478 * check whether the identifier is a single-line macro at
3479 * all, then think about checking for parameters if
3482 for (m
= head
; m
; m
= m
->next
)
3483 if (!mstrcmp(m
->name
, mname
, m
->casesense
))
3489 if (m
->nparam
== 0) {
3491 * Simple case: the macro is parameterless. Discard the
3492 * one token that the macro call took, and push the
3493 * expansion back on the to-do stack.
3495 if (!m
->expansion
) {
3496 if (!strcmp("__FILE__", m
->name
)) {
3499 src_get(&num
, &file
);
3500 tline
->text
= nasm_quote(file
, strlen(file
));
3501 tline
->type
= TOK_STRING
;
3505 if (!strcmp("__LINE__", m
->name
)) {
3506 nasm_free(tline
->text
);
3507 make_tok_num(tline
, src_get_linnum());
3510 if (!strcmp("__BITS__", m
->name
)) {
3511 nasm_free(tline
->text
);
3512 make_tok_num(tline
, globalbits
);
3515 tline
= delete_Token(tline
);
3520 * Complicated case: at least one macro with this name
3521 * exists and takes parameters. We must find the
3522 * parameters in the call, count them, find the SMacro
3523 * that corresponds to that form of the macro call, and
3524 * substitute for the parameters when we expand. What a
3527 /*tline = tline->next;
3528 skip_white_(tline); */
3531 while (tok_type_(t
, TOK_SMAC_END
)) {
3532 t
->a
.mac
->in_progress
= false;
3534 t
= tline
->next
= delete_Token(t
);
3537 } while (tok_type_(tline
, TOK_WHITESPACE
));
3538 if (!tok_is_(tline
, "(")) {
3540 * This macro wasn't called with parameters: ignore
3541 * the call. (Behaviour borrowed from gnu cpp.)
3550 sparam
= PARAM_DELTA
;
3551 params
= nasm_malloc(sparam
* sizeof(Token
*));
3552 params
[0] = tline
->next
;
3553 paramsize
= nasm_malloc(sparam
* sizeof(int));
3555 while (true) { /* parameter loop */
3557 * For some unusual expansions
3558 * which concatenates function call
3561 while (tok_type_(t
, TOK_SMAC_END
)) {
3562 t
->a
.mac
->in_progress
= false;
3564 t
= tline
->next
= delete_Token(t
);
3570 "macro call expects terminating `)'");
3573 if (tline
->type
== TOK_WHITESPACE
3575 if (paramsize
[nparam
])
3578 params
[nparam
] = tline
->next
;
3579 continue; /* parameter loop */
3581 if (tline
->type
== TOK_OTHER
3582 && tline
->text
[1] == 0) {
3583 char ch
= tline
->text
[0];
3584 if (ch
== ',' && !paren
&& brackets
<= 0) {
3585 if (++nparam
>= sparam
) {
3586 sparam
+= PARAM_DELTA
;
3587 params
= nasm_realloc(params
,
3592 nasm_realloc(paramsize
,
3596 params
[nparam
] = tline
->next
;
3597 paramsize
[nparam
] = 0;
3599 continue; /* parameter loop */
3602 (brackets
> 0 || (brackets
== 0 &&
3603 !paramsize
[nparam
])))
3605 if (!(brackets
++)) {
3606 params
[nparam
] = tline
->next
;
3607 continue; /* parameter loop */
3610 if (ch
== '}' && brackets
> 0)
3611 if (--brackets
== 0) {
3613 continue; /* parameter loop */
3615 if (ch
== '(' && !brackets
)
3617 if (ch
== ')' && brackets
<= 0)
3623 error(ERR_NONFATAL
, "braces do not "
3624 "enclose all of macro parameter");
3626 paramsize
[nparam
] += white
+ 1;
3628 } /* parameter loop */
3630 while (m
&& (m
->nparam
!= nparam
||
3631 mstrcmp(m
->name
, mname
,
3635 error(ERR_WARNING
| ERR_WARN_MNP
,
3636 "macro `%s' exists, "
3637 "but not taking %d parameters",
3638 mstart
->text
, nparam
);
3641 if (m
&& m
->in_progress
)
3643 if (!m
) { /* in progess or didn't find '(' or wrong nparam */
3645 * Design question: should we handle !tline, which
3646 * indicates missing ')' here, or expand those
3647 * macros anyway, which requires the (t) test a few
3651 nasm_free(paramsize
);
3655 * Expand the macro: we are placed on the last token of the
3656 * call, so that we can easily split the call from the
3657 * following tokens. We also start by pushing an SMAC_END
3658 * token for the cycle removal.
3665 tt
= new_Token(tline
, TOK_SMAC_END
, NULL
, 0);
3667 m
->in_progress
= true;
3669 for (t
= m
->expansion
; t
; t
= t
->next
) {
3670 if (t
->type
>= TOK_SMAC_PARAM
) {
3671 Token
*pcopy
= tline
, **ptail
= &pcopy
;
3675 ttt
= params
[t
->type
- TOK_SMAC_PARAM
];
3676 for (i
= paramsize
[t
->type
- TOK_SMAC_PARAM
];
3679 new_Token(tline
, ttt
->type
, ttt
->text
,
3685 } else if (t
->type
== TOK_PREPROC_Q
) {
3686 tt
= new_Token(tline
, TOK_ID
, mname
, 0);
3688 } else if (t
->type
== TOK_PREPROC_QQ
) {
3689 tt
= new_Token(tline
, TOK_ID
, m
->name
, 0);
3692 tt
= new_Token(tline
, t
->type
, t
->text
, 0);
3698 * Having done that, get rid of the macro call, and clean
3699 * up the parameters.
3702 nasm_free(paramsize
);
3704 continue; /* main token loop */
3709 if (tline
->type
== TOK_SMAC_END
) {
3710 tline
->a
.mac
->in_progress
= false;
3711 tline
= delete_Token(tline
);
3714 tline
= tline
->next
;
3722 * Now scan the entire line and look for successive TOK_IDs that resulted
3723 * after expansion (they can't be produced by tokenize()). The successive
3724 * TOK_IDs should be concatenated.
3725 * Also we look for %+ tokens and concatenate the tokens before and after
3726 * them (without white spaces in between).
3731 while (t
&& t
->type
!= TOK_ID
&& t
->type
!= TOK_PREPROC_ID
)
3735 if (t
->next
->type
== TOK_ID
||
3736 t
->next
->type
== TOK_PREPROC_ID
||
3737 t
->next
->type
== TOK_NUMBER
) {
3738 char *p
= nasm_strcat(t
->text
, t
->next
->text
);
3740 t
->next
= delete_Token(t
->next
);
3743 } else if (t
->next
->type
== TOK_WHITESPACE
&& t
->next
->next
&&
3744 t
->next
->next
->type
== TOK_PREPROC_ID
&&
3745 strcmp(t
->next
->next
->text
, "%+") == 0) {
3746 /* free the next whitespace, the %+ token and next whitespace */
3748 for (i
= 1; i
<= 3; i
++) {
3750 || (i
!= 2 && t
->next
->type
!= TOK_WHITESPACE
))
3752 t
->next
= delete_Token(t
->next
);
3757 /* If we concatenaded something, re-scan the line for macros */
3765 *org_tline
= *thead
;
3766 /* since we just gave text to org_line, don't free it */
3768 delete_Token(thead
);
3770 /* the expression expanded to empty line;
3771 we can't return NULL for some reasons
3772 we just set the line to a single WHITESPACE token. */
3773 memset(org_tline
, 0, sizeof(*org_tline
));
3774 org_tline
->text
= NULL
;
3775 org_tline
->type
= TOK_WHITESPACE
;
3784 * Similar to expand_smacro but used exclusively with macro identifiers
3785 * right before they are fetched in. The reason is that there can be
3786 * identifiers consisting of several subparts. We consider that if there
3787 * are more than one element forming the name, user wants a expansion,
3788 * otherwise it will be left as-is. Example:
3792 * the identifier %$abc will be left as-is so that the handler for %define
3793 * will suck it and define the corresponding value. Other case:
3795 * %define _%$abc cde
3797 * In this case user wants name to be expanded *before* %define starts
3798 * working, so we'll expand %$abc into something (if it has a value;
3799 * otherwise it will be left as-is) then concatenate all successive
3802 static Token
*expand_id(Token
* tline
)
3804 Token
*cur
, *oldnext
= NULL
;
3806 if (!tline
|| !tline
->next
)
3811 (cur
->next
->type
== TOK_ID
||
3812 cur
->next
->type
== TOK_PREPROC_ID
3813 || cur
->next
->type
== TOK_NUMBER
))
3816 /* If identifier consists of just one token, don't expand */
3821 oldnext
= cur
->next
; /* Detach the tail past identifier */
3822 cur
->next
= NULL
; /* so that expand_smacro stops here */
3825 tline
= expand_smacro(tline
);
3828 /* expand_smacro possibly changhed tline; re-scan for EOL */
3830 while (cur
&& cur
->next
)
3833 cur
->next
= oldnext
;
3840 * Determine whether the given line constitutes a multi-line macro
3841 * call, and return the MMacro structure called if so. Doesn't have
3842 * to check for an initial label - that's taken care of in
3843 * expand_mmacro - but must check numbers of parameters. Guaranteed
3844 * to be called with tline->type == TOK_ID, so the putative macro
3845 * name is easy to find.
3847 static MMacro
*is_mmacro(Token
* tline
, Token
*** params_array
)
3853 head
= (MMacro
*) hash_findix(&mmacros
, tline
->text
);
3856 * Efficiency: first we see if any macro exists with the given
3857 * name. If not, we can return NULL immediately. _Then_ we
3858 * count the parameters, and then we look further along the
3859 * list if necessary to find the proper MMacro.
3861 for (m
= head
; m
; m
= m
->next
)
3862 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
3868 * OK, we have a potential macro. Count and demarcate the
3871 count_mmac_params(tline
->next
, &nparam
, ¶ms
);
3874 * So we know how many parameters we've got. Find the MMacro
3875 * structure that handles this number.
3878 if (m
->nparam_min
<= nparam
3879 && (m
->plus
|| nparam
<= m
->nparam_max
)) {
3881 * This one is right. Just check if cycle removal
3882 * prohibits us using it before we actually celebrate...
3884 if (m
->in_progress
) {
3887 "self-reference in multi-line macro `%s'", m
->name
);
3893 * It's right, and we can use it. Add its default
3894 * parameters to the end of our list if necessary.
3896 if (m
->defaults
&& nparam
< m
->nparam_min
+ m
->ndefs
) {
3898 nasm_realloc(params
,
3899 ((m
->nparam_min
+ m
->ndefs
+
3900 1) * sizeof(*params
)));
3901 while (nparam
< m
->nparam_min
+ m
->ndefs
) {
3902 params
[nparam
] = m
->defaults
[nparam
- m
->nparam_min
];
3907 * If we've gone over the maximum parameter count (and
3908 * we're in Plus mode), ignore parameters beyond
3911 if (m
->plus
&& nparam
> m
->nparam_max
)
3912 nparam
= m
->nparam_max
;
3914 * Then terminate the parameter list, and leave.
3916 if (!params
) { /* need this special case */
3917 params
= nasm_malloc(sizeof(*params
));
3920 params
[nparam
] = NULL
;
3921 *params_array
= params
;
3925 * This one wasn't right: look for the next one with the
3928 for (m
= m
->next
; m
; m
= m
->next
)
3929 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
3934 * After all that, we didn't find one with the right number of
3935 * parameters. Issue a warning, and fail to expand the macro.
3937 error(ERR_WARNING
| ERR_WARN_MNP
,
3938 "macro `%s' exists, but not taking %d parameters",
3939 tline
->text
, nparam
);
3945 * Expand the multi-line macro call made by the given line, if
3946 * there is one to be expanded. If there is, push the expansion on
3947 * istk->expansion and return 1. Otherwise return 0.
3949 static int expand_mmacro(Token
* tline
)
3951 Token
*startline
= tline
;
3952 Token
*label
= NULL
;
3953 int dont_prepend
= 0;
3954 Token
**params
, *t
, *mtok
, *tt
;
3957 int i
, nparam
, *paramlen
;
3962 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
3963 if (!tok_type_(t
, TOK_ID
) && !tok_type_(t
, TOK_PREPROC_ID
))
3966 m
= is_mmacro(t
, ¶ms
);
3972 * We have an id which isn't a macro call. We'll assume
3973 * it might be a label; we'll also check to see if a
3974 * colon follows it. Then, if there's another id after
3975 * that lot, we'll check it again for macro-hood.
3979 if (tok_type_(t
, TOK_WHITESPACE
))
3980 last
= t
, t
= t
->next
;
3981 if (tok_is_(t
, ":")) {
3983 last
= t
, t
= t
->next
;
3984 if (tok_type_(t
, TOK_WHITESPACE
))
3985 last
= t
, t
= t
->next
;
3987 if (!tok_type_(t
, TOK_ID
) || (m
= is_mmacro(t
, ¶ms
)) == NULL
)
3995 * Fix up the parameters: this involves stripping leading and
3996 * trailing whitespace, then stripping braces if they are
3999 for (nparam
= 0; params
[nparam
]; nparam
++) ;
4000 paramlen
= nparam
? nasm_malloc(nparam
* sizeof(*paramlen
)) : NULL
;
4002 for (i
= 0; params
[i
]; i
++) {
4004 int comma
= (!m
->plus
|| i
< nparam
- 1);
4008 if (tok_is_(t
, "{"))
4009 t
= t
->next
, brace
= true, comma
= false;
4013 if (comma
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, ","))
4014 break; /* ... because we have hit a comma */
4015 if (comma
&& t
->type
== TOK_WHITESPACE
4016 && tok_is_(t
->next
, ","))
4017 break; /* ... or a space then a comma */
4018 if (brace
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, "}"))
4019 break; /* ... or a brace */
4026 * OK, we have a MMacro structure together with a set of
4027 * parameters. We must now go through the expansion and push
4028 * copies of each Line on to istk->expansion. Substitution of
4029 * parameter tokens and macro-local tokens doesn't get done
4030 * until the single-line macro substitution process; this is
4031 * because delaying them allows us to change the semantics
4032 * later through %rotate.
4034 * First, push an end marker on to istk->expansion, mark this
4035 * macro as in progress, and set up its invocation-specific
4038 ll
= nasm_malloc(sizeof(Line
));
4039 ll
->next
= istk
->expansion
;
4042 istk
->expansion
= ll
;
4044 m
->in_progress
= true;
4049 m
->paramlen
= paramlen
;
4050 m
->unique
= unique
++;
4053 m
->next_active
= istk
->mstk
;
4056 for (l
= m
->expansion
; l
; l
= l
->next
) {
4059 ll
= nasm_malloc(sizeof(Line
));
4060 ll
->finishes
= NULL
;
4061 ll
->next
= istk
->expansion
;
4062 istk
->expansion
= ll
;
4065 for (t
= l
->first
; t
; t
= t
->next
) {
4069 tt
= *tail
= new_Token(NULL
, TOK_ID
, mname
, 0);
4071 case TOK_PREPROC_QQ
:
4072 tt
= *tail
= new_Token(NULL
, TOK_ID
, m
->name
, 0);
4074 case TOK_PREPROC_ID
:
4075 if (t
->text
[1] == '0' && t
->text
[2] == '0') {
4083 tt
= *tail
= new_Token(NULL
, x
->type
, x
->text
, 0);
4092 * If we had a label, push it on as the first line of
4093 * the macro expansion.
4096 if (dont_prepend
< 0)
4097 free_tlist(startline
);
4099 ll
= nasm_malloc(sizeof(Line
));
4100 ll
->finishes
= NULL
;
4101 ll
->next
= istk
->expansion
;
4102 istk
->expansion
= ll
;
4103 ll
->first
= startline
;
4104 if (!dont_prepend
) {
4106 label
= label
->next
;
4107 label
->next
= tt
= new_Token(NULL
, TOK_OTHER
, ":", 0);
4112 list
->uplevel(m
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
4118 * Since preprocessor always operate only on the line that didn't
4119 * arrived yet, we should always use ERR_OFFBY1. Also since user
4120 * won't want to see same error twice (preprocessing is done once
4121 * per pass) we will want to show errors only during pass one.
4123 static void error(int severity
, const char *fmt
, ...)
4128 /* If we're in a dead branch of IF or something like it, ignore the error */
4129 if (istk
&& istk
->conds
&& !emitting(istk
->conds
->state
))
4133 vsnprintf(buff
, sizeof(buff
), fmt
, arg
);
4136 if (istk
&& istk
->mstk
&& istk
->mstk
->name
)
4137 _error(severity
| ERR_PASS1
, "(%s:%d) %s", istk
->mstk
->name
,
4138 istk
->mstk
->lineno
, buff
);
4140 _error(severity
| ERR_PASS1
, "%s", buff
);
4144 pp_reset(char *file
, int apass
, efunc errfunc
, evalfunc eval
,
4145 ListGen
* listgen
, StrList
**deplist
)
4149 istk
= nasm_malloc(sizeof(Include
));
4152 istk
->expansion
= NULL
;
4154 istk
->fp
= fopen(file
, "r");
4156 src_set_fname(nasm_strdup(file
));
4160 error(ERR_FATAL
| ERR_NOFILE
, "unable to open input file `%s'",
4163 nested_mac_count
= 0;
4164 nested_rep_count
= 0;
4167 if (tasm_compatible_mode
) {
4168 stdmacpos
= nasm_stdmac
;
4170 stdmacpos
= nasm_stdmac_after_tasm
;
4172 any_extrastdmac
= extrastdmac
&& *extrastdmac
;
4177 dephead
= deptail
= deplist
;
4179 StrList
*sl
= nasm_malloc(strlen(file
)+1+sizeof sl
->next
);
4181 strcpy(sl
->str
, file
);
4183 deptail
= &sl
->next
;
4187 static char *pp_getline(void)
4194 * Fetch a tokenized line, either from the macro-expansion
4195 * buffer or from the input file.
4198 while (istk
->expansion
&& istk
->expansion
->finishes
) {
4199 Line
*l
= istk
->expansion
;
4200 if (!l
->finishes
->name
&& l
->finishes
->in_progress
> 1) {
4204 * This is a macro-end marker for a macro with no
4205 * name, which means it's not really a macro at all
4206 * but a %rep block, and the `in_progress' field is
4207 * more than 1, meaning that we still need to
4208 * repeat. (1 means the natural last repetition; 0
4209 * means termination by %exitrep.) We have
4210 * therefore expanded up to the %endrep, and must
4211 * push the whole block on to the expansion buffer
4212 * again. We don't bother to remove the macro-end
4213 * marker: we'd only have to generate another one
4216 l
->finishes
->in_progress
--;
4217 for (l
= l
->finishes
->expansion
; l
; l
= l
->next
) {
4218 Token
*t
, *tt
, **tail
;
4220 ll
= nasm_malloc(sizeof(Line
));
4221 ll
->next
= istk
->expansion
;
4222 ll
->finishes
= NULL
;
4226 for (t
= l
->first
; t
; t
= t
->next
) {
4227 if (t
->text
|| t
->type
== TOK_WHITESPACE
) {
4229 new_Token(NULL
, t
->type
, t
->text
, 0);
4234 istk
->expansion
= ll
;
4238 * Check whether a `%rep' was started and not ended
4239 * within this macro expansion. This can happen and
4240 * should be detected. It's a fatal error because
4241 * I'm too confused to work out how to recover
4247 "defining with name in expansion");
4248 else if (istk
->mstk
->name
)
4250 "`%%rep' without `%%endrep' within"
4251 " expansion of macro `%s'",
4256 * FIXME: investigate the relationship at this point between
4257 * istk->mstk and l->finishes
4260 MMacro
*m
= istk
->mstk
;
4261 istk
->mstk
= m
->next_active
;
4264 * This was a real macro call, not a %rep, and
4265 * therefore the parameter information needs to
4268 nasm_free(m
->params
);
4269 free_tlist(m
->iline
);
4270 nasm_free(m
->paramlen
);
4271 l
->finishes
->in_progress
= false;
4275 istk
->expansion
= l
->next
;
4277 list
->downlevel(LIST_MACRO
);
4280 while (1) { /* until we get a line we can use */
4282 if (istk
->expansion
) { /* from a macro expansion */
4284 Line
*l
= istk
->expansion
;
4286 istk
->mstk
->lineno
++;
4288 istk
->expansion
= l
->next
;
4290 p
= detoken(tline
, false);
4291 list
->line(LIST_MACRO
, p
);
4296 if (line
) { /* from the current input file */
4297 line
= prepreproc(line
);
4298 tline
= tokenize(line
);
4303 * The current file has ended; work down the istk
4310 "expected `%%endif' before end of file");
4311 /* only set line and file name if there's a next node */
4313 src_set_linnum(i
->lineno
);
4314 nasm_free(src_set_fname(i
->fname
));
4317 list
->downlevel(LIST_INCLUDE
);
4325 * We must expand MMacro parameters and MMacro-local labels
4326 * _before_ we plunge into directive processing, to cope
4327 * with things like `%define something %1' such as STRUC
4328 * uses. Unless we're _defining_ a MMacro, in which case
4329 * those tokens should be left alone to go into the
4330 * definition; and unless we're in a non-emitting
4331 * condition, in which case we don't want to meddle with
4334 if (!defining
&& !(istk
->conds
&& !emitting(istk
->conds
->state
))
4335 && !(istk
->mstk
&& !istk
->mstk
->in_progress
))
4336 tline
= expand_mmac_params(tline
);
4339 * Check the line to see if it's a preprocessor directive.
4341 if (do_directive(tline
) == DIRECTIVE_FOUND
) {
4343 } else if (defining
) {
4345 * We're defining a multi-line macro. We emit nothing
4347 * shove the tokenized line on to the macro definition.
4349 Line
*l
= nasm_malloc(sizeof(Line
));
4350 l
->next
= defining
->expansion
;
4353 defining
->expansion
= l
;
4355 } else if (istk
->conds
&& !emitting(istk
->conds
->state
)) {
4357 * We're in a non-emitting branch of a condition block.
4358 * Emit nothing at all, not even a blank line: when we
4359 * emerge from the condition we'll give a line-number
4360 * directive so we keep our place correctly.
4364 } else if (istk
->mstk
&& !istk
->mstk
->in_progress
) {
4366 * We're in a %rep block which has been terminated, so
4367 * we're walking through to the %endrep without
4368 * emitting anything. Emit nothing at all, not even a
4369 * blank line: when we emerge from the %rep block we'll
4370 * give a line-number directive so we keep our place
4376 tline
= expand_smacro(tline
);
4377 if (!expand_mmacro(tline
)) {
4379 * De-tokenize the line again, and emit it.
4381 line
= detoken(tline
, true);
4385 continue; /* expand_mmacro calls free_tlist */
4393 static void pp_cleanup(int pass
)
4396 if(defining
->name
) {
4398 "end of file while still defining macro `%s'",
4401 error(ERR_NONFATAL
, "end of file while still in %%rep");
4404 free_mmacro(defining
);
4413 nasm_free(i
->fname
);
4418 nasm_free(src_set_fname(NULL
));
4423 while ((i
= ipath
)) {
4432 void pp_include_path(char *path
)
4436 i
= nasm_malloc(sizeof(IncPath
));
4437 i
->path
= path
? nasm_strdup(path
) : NULL
;
4440 if (ipath
!= NULL
) {
4442 while (j
->next
!= NULL
)
4450 void pp_pre_include(char *fname
)
4452 Token
*inc
, *space
, *name
;
4455 name
= new_Token(NULL
, TOK_INTERNAL_STRING
, fname
, 0);
4456 space
= new_Token(name
, TOK_WHITESPACE
, NULL
, 0);
4457 inc
= new_Token(space
, TOK_PREPROC_ID
, "%include", 0);
4459 l
= nasm_malloc(sizeof(Line
));
4466 void pp_pre_define(char *definition
)
4472 equals
= strchr(definition
, '=');
4473 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4474 def
= new_Token(space
, TOK_PREPROC_ID
, "%define", 0);
4477 space
->next
= tokenize(definition
);
4481 l
= nasm_malloc(sizeof(Line
));
4488 void pp_pre_undefine(char *definition
)
4493 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4494 def
= new_Token(space
, TOK_PREPROC_ID
, "%undef", 0);
4495 space
->next
= tokenize(definition
);
4497 l
= nasm_malloc(sizeof(Line
));
4505 * Added by Keith Kanios:
4507 * This function is used to assist with "runtime" preprocessor
4508 * directives. (e.g. pp_runtime("%define __BITS__ 64");)
4510 * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
4511 * PASS A VALID STRING TO THIS FUNCTION!!!!!
4514 void pp_runtime(char *definition
)
4518 def
= tokenize(definition
);
4519 if(do_directive(def
) == NO_DIRECTIVE_FOUND
)
4524 void pp_extra_stdmac(macros_t
*macros
)
4526 extrastdmac
= macros
;
4529 static void make_tok_num(Token
* tok
, int64_t val
)
4532 snprintf(numbuf
, sizeof(numbuf
), "%"PRId64
"", val
);
4533 tok
->text
= nasm_strdup(numbuf
);
4534 tok
->type
= TOK_NUMBER
;