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_INDIRECT
, /* %[...] */
163 TOK_SMAC_PARAM
, /* MUST BE LAST IN THE LIST!!! */
164 TOK_MAX
= INT_MAX
/* Keep compiler from reducing the range */
171 SMacro
*mac
; /* associated macro for TOK_SMAC_END */
172 size_t len
; /* scratch length field */
173 } a
; /* Auxiliary data */
174 enum pp_token_type type
;
178 * Multi-line macro definitions are stored as a linked list of
179 * these, which is essentially a container to allow several linked
182 * Note that in this module, linked lists are treated as stacks
183 * wherever possible. For this reason, Lines are _pushed_ on to the
184 * `expansion' field in MMacro structures, so that the linked list,
185 * if walked, would give the macro lines in reverse order; this
186 * means that we can walk the list when expanding a macro, and thus
187 * push the lines on to the `expansion' field in _istk_ in reverse
188 * order (so that when popped back off they are in the right
189 * order). It may seem cockeyed, and it relies on my design having
190 * an even number of steps in, but it works...
192 * Some of these structures, rather than being actual lines, are
193 * markers delimiting the end of the expansion of a given macro.
194 * This is for use in the cycle-tracking and %rep-handling code.
195 * Such structures have `finishes' non-NULL, and `first' NULL. All
196 * others have `finishes' NULL, but `first' may still be NULL if
206 * To handle an arbitrary level of file inclusion, we maintain a
207 * stack (ie linked list) of these things.
216 MMacro
*mstk
; /* stack of active macros/reps */
220 * Include search path. This is simply a list of strings which get
221 * prepended, in turn, to the name of an include file, in an
222 * attempt to find the file if it's not in the current directory.
230 * Conditional assembly: we maintain a separate stack of these for
231 * each level of file inclusion. (The only reason we keep the
232 * stacks separate is to ensure that a stray `%endif' in a file
233 * included from within the true branch of a `%if' won't terminate
234 * it and cause confusion: instead, rightly, it'll cause an error.)
242 * These states are for use just after %if or %elif: IF_TRUE
243 * means the condition has evaluated to truth so we are
244 * currently emitting, whereas IF_FALSE means we are not
245 * currently emitting but will start doing so if a %else comes
246 * up. In these states, all directives are admissible: %elif,
247 * %else and %endif. (And of course %if.)
249 COND_IF_TRUE
, COND_IF_FALSE
,
251 * These states come up after a %else: ELSE_TRUE means we're
252 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
253 * any %elif or %else will cause an error.
255 COND_ELSE_TRUE
, COND_ELSE_FALSE
,
257 * These states mean that we're not emitting now, and also that
258 * nothing until %endif will be emitted at all. COND_DONE is
259 * used when we've had our moment of emission
260 * and have now started seeing %elifs. COND_NEVER is used when
261 * the condition construct in question is contained within a
262 * non-emitting branch of a larger condition construct,
263 * or if there is an error.
265 COND_DONE
, COND_NEVER
267 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
270 * These defines are used as the possible return values for do_directive
272 #define NO_DIRECTIVE_FOUND 0
273 #define DIRECTIVE_FOUND 1
276 * Condition codes. Note that we use c_ prefix not C_ because C_ is
277 * used in nasm.h for the "real" condition codes. At _this_ level,
278 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
279 * ones, so we need a different enum...
281 static const char * const conditions
[] = {
282 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
283 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
284 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
287 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_CXZ
, c_E
, c_ECXZ
, c_G
, c_GE
, c_L
, c_LE
,
288 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, c_NE
, c_NG
, c_NGE
, c_NL
, c_NLE
, c_NO
,
289 c_NP
, c_NS
, c_NZ
, c_O
, c_P
, c_PE
, c_PO
, c_RCXZ
, c_S
, c_Z
,
292 static const enum pp_conds inverse_ccs
[] = {
293 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, -1, c_NE
, -1, c_NG
, c_NGE
, c_NL
, c_NLE
,
294 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
,
295 c_Z
, c_NO
, c_NP
, c_PO
, c_PE
, -1, c_NS
, c_NZ
301 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
302 static int is_condition(enum preproc_token arg
)
304 return PP_IS_COND(arg
) || (arg
== PP_ELSE
) || (arg
== PP_ENDIF
);
307 /* For TASM compatibility we need to be able to recognise TASM compatible
308 * conditional compilation directives. Using the NASM pre-processor does
309 * not work, so we look for them specifically from the following list and
310 * then jam in the equivalent NASM directive into the input stream.
314 TM_ARG
, TM_ELIF
, TM_ELSE
, TM_ENDIF
, TM_IF
, TM_IFDEF
, TM_IFDIFI
,
315 TM_IFNDEF
, TM_INCLUDE
, TM_LOCAL
318 static const char * const tasm_directives
[] = {
319 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
320 "ifndef", "include", "local"
323 static int StackSize
= 4;
324 static char *StackPointer
= "ebp";
325 static int ArgOffset
= 8;
326 static int LocalOffset
= 0;
328 static Context
*cstk
;
329 static Include
*istk
;
330 static IncPath
*ipath
= NULL
;
332 static efunc _error
; /* Pointer to client-provided error reporting function */
333 static evalfunc evaluate
;
335 static int pass
; /* HACK: pass 0 = generate dependencies only */
336 static StrList
**dephead
, **deptail
; /* Dependency list */
338 static uint64_t unique
; /* unique identifier numbers */
340 static Line
*predef
= NULL
;
341 static bool do_predef
;
343 static ListGen
*list
;
346 * The current set of multi-line macros we have defined.
348 static struct hash_table mmacros
;
351 * The current set of single-line macros we have defined.
353 static struct hash_table smacros
;
356 * The multi-line macro we are currently defining, or the %rep
357 * block we are currently reading, if any.
359 static MMacro
*defining
;
361 static uint64_t nested_mac_count
;
362 static uint64_t nested_rep_count
;
365 * The number of macro parameters to allocate space for at a time.
367 #define PARAM_DELTA 16
370 * The standard macro set: defined in macros.c in the array nasm_stdmac.
371 * This gives our position in the macro set, when we're processing it.
373 static macros_t
*stdmacpos
;
376 * The extra standard macros that come from the object format, if
379 static macros_t
*extrastdmac
= NULL
;
380 static bool any_extrastdmac
;
383 * Tokens are allocated in blocks to improve speed
385 #define TOKEN_BLOCKSIZE 4096
386 static Token
*freeTokens
= NULL
;
392 static Blocks blocks
= { NULL
, NULL
};
395 * Forward declarations.
397 static Token
*expand_mmac_params(Token
* tline
);
398 static Token
*expand_smacro(Token
* tline
);
399 static Token
*expand_id(Token
* tline
);
400 static Token
*expand_indirect(Token
* tline
, int level
);
401 static Context
*get_ctx(const char *name
, bool all_contexts
);
402 static void make_tok_num(Token
* tok
, int64_t val
);
403 static void error(int severity
, const char *fmt
, ...);
404 static void error_precond(int severity
, const char *fmt
, ...);
405 static void *new_Block(size_t size
);
406 static void delete_Blocks(void);
407 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
408 const char *text
, int txtlen
);
409 static Token
*delete_Token(Token
* t
);
412 * Macros for safe checking of token pointers, avoid *(NULL)
414 #define tok_type_(x,t) ((x) && (x)->type == (t))
415 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
416 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
417 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
419 /* Handle TASM specific directives, which do not contain a % in
420 * front of them. We do it here because I could not find any other
421 * place to do it for the moment, and it is a hack (ideally it would
422 * be nice to be able to use the NASM pre-processor to do it).
424 static char *check_tasm_directive(char *line
)
426 int32_t i
, j
, k
, m
, len
;
427 char *p
= line
, *oldline
, oldchar
;
429 /* Skip whitespace */
430 while (nasm_isspace(*p
) && *p
!= 0)
433 /* Binary search for the directive name */
435 j
= elements(tasm_directives
);
437 while (!nasm_isspace(p
[len
]) && p
[len
] != 0)
444 m
= nasm_stricmp(p
, tasm_directives
[k
]);
446 /* We have found a directive, so jam a % in front of it
447 * so that NASM will then recognise it as one if it's own.
452 line
= nasm_malloc(len
+ 2);
454 if (k
== TM_IFDIFI
) {
455 /* NASM does not recognise IFDIFI, so we convert it to
456 * %ifdef BOGUS. This is not used in NASM comaptible
457 * code, but does need to parse for the TASM macro
460 strcpy(line
+ 1, "ifdef BOGUS");
462 memcpy(line
+ 1, p
, len
+ 1);
477 * The pre-preprocessing stage... This function translates line
478 * number indications as they emerge from GNU cpp (`# lineno "file"
479 * flags') into NASM preprocessor line number indications (`%line
482 static char *prepreproc(char *line
)
485 char *fname
, *oldline
;
487 if (line
[0] == '#' && line
[1] == ' ') {
490 lineno
= atoi(fname
);
491 fname
+= strspn(fname
, "0123456789 ");
494 fnlen
= strcspn(fname
, "\"");
495 line
= nasm_malloc(20 + fnlen
);
496 snprintf(line
, 20 + fnlen
, "%%line %d %.*s", lineno
, fnlen
, fname
);
499 if (tasm_compatible_mode
)
500 return check_tasm_directive(line
);
505 * Free a linked list of tokens.
507 static void free_tlist(Token
* list
)
510 list
= delete_Token(list
);
515 * Free a linked list of lines.
517 static void free_llist(Line
* list
)
523 free_tlist(l
->first
);
531 static void free_mmacro(MMacro
* m
)
534 free_tlist(m
->dlist
);
535 nasm_free(m
->defaults
);
536 free_llist(m
->expansion
);
541 * Free all currently defined macros, and free the hash tables
543 static void free_smacro_table(struct hash_table
*smt
)
547 struct hash_tbl_node
*it
= NULL
;
549 while ((s
= hash_iterate(smt
, &it
, &key
)) != NULL
) {
550 nasm_free((void *)key
);
552 SMacro
*ns
= s
->next
;
554 free_tlist(s
->expansion
);
562 static void free_mmacro_table(struct hash_table
*mmt
)
566 struct hash_tbl_node
*it
= NULL
;
569 while ((m
= hash_iterate(mmt
, &it
, &key
)) != NULL
) {
570 nasm_free((void *)key
);
572 MMacro
*nm
= m
->next
;
580 static void free_macros(void)
582 free_smacro_table(&smacros
);
583 free_mmacro_table(&mmacros
);
587 * Initialize the hash tables
589 static void init_macros(void)
591 hash_init(&smacros
, HASH_LARGE
);
592 hash_init(&mmacros
, HASH_LARGE
);
596 * Pop the context stack.
598 static void ctx_pop(void)
603 free_smacro_table(&c
->localmac
);
609 * Search for a key in the hash index; adding it if necessary
610 * (in which case we initialize the data pointer to NULL.)
613 hash_findi_add(struct hash_table
*hash
, const char *str
)
615 struct hash_insert hi
;
619 r
= hash_findi(hash
, str
, &hi
);
623 strx
= nasm_strdup(str
); /* Use a more efficient allocator here? */
624 return hash_add(&hi
, strx
, NULL
);
628 * Like hash_findi, but returns the data element rather than a pointer
629 * to it. Used only when not adding a new element, hence no third
633 hash_findix(struct hash_table
*hash
, const char *str
)
637 p
= hash_findi(hash
, str
, NULL
);
638 return p
? *p
: NULL
;
641 #define BUF_DELTA 512
643 * Read a line from the top file in istk, handling multiple CR/LFs
644 * at the end of the line read, and handling spurious ^Zs. Will
645 * return lines from the standard macro set if this has not already
648 static char *read_line(void)
650 char *buffer
, *p
, *q
;
651 int bufsize
, continued_count
;
655 const unsigned char *p
= stdmacpos
;
660 len
+= pp_directives_len
[c
-0x80]+1;
664 ret
= nasm_malloc(len
+1);
666 while ((c
= *stdmacpos
++)) {
668 memcpy(q
, pp_directives
[c
-0x80], pp_directives_len
[c
-0x80]);
669 q
+= pp_directives_len
[c
-0x80];
679 /* This was the last of the standard macro chain... */
681 if (any_extrastdmac
) {
682 stdmacpos
= extrastdmac
;
683 any_extrastdmac
= false;
684 } else if (do_predef
) {
686 Token
*head
, **tail
, *t
;
689 * Nasty hack: here we push the contents of
690 * `predef' on to the top-level expansion stack,
691 * since this is the most convenient way to
692 * implement the pre-include and pre-define
695 for (pd
= predef
; pd
; pd
= pd
->next
) {
698 for (t
= pd
->first
; t
; t
= t
->next
) {
699 *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
700 tail
= &(*tail
)->next
;
702 l
= nasm_malloc(sizeof(Line
));
703 l
->next
= istk
->expansion
;
715 buffer
= nasm_malloc(BUF_DELTA
);
719 q
= fgets(p
, bufsize
- (p
- buffer
), istk
->fp
);
723 if (p
> buffer
&& p
[-1] == '\n') {
724 /* Convert backslash-CRLF line continuation sequences into
725 nothing at all (for DOS and Windows) */
726 if (((p
- 2) > buffer
) && (p
[-3] == '\\') && (p
[-2] == '\r')) {
731 /* Also convert backslash-LF line continuation sequences into
732 nothing at all (for Unix) */
733 else if (((p
- 1) > buffer
) && (p
[-2] == '\\')) {
741 if (p
- buffer
> bufsize
- 10) {
742 int32_t offset
= p
- buffer
;
743 bufsize
+= BUF_DELTA
;
744 buffer
= nasm_realloc(buffer
, bufsize
);
745 p
= buffer
+ offset
; /* prevent stale-pointer problems */
749 if (!q
&& p
== buffer
) {
754 src_set_linnum(src_get_linnum() + istk
->lineinc
+
755 (continued_count
* istk
->lineinc
));
758 * Play safe: remove CRs as well as LFs, if any of either are
759 * present at the end of the line.
761 while (--p
>= buffer
&& (*p
== '\n' || *p
== '\r'))
765 * Handle spurious ^Z, which may be inserted into source files
766 * by some file transfer utilities.
768 buffer
[strcspn(buffer
, "\032")] = '\0';
770 list
->line(LIST_READ
, buffer
);
776 * Tokenize a line of text. This is a very simple process since we
777 * don't need to parse the value out of e.g. numeric tokens: we
778 * simply split one string into many.
780 static Token
*tokenize(char *line
)
783 enum pp_token_type type
;
785 Token
*t
, **tail
= &list
;
791 if (nasm_isdigit(*p
) ||
792 ((*p
== '-' || *p
== '+') && nasm_isdigit(p
[1])) ||
793 ((*p
== '+') && (nasm_isspace(p
[1]) || !p
[1]))) {
797 while (nasm_isdigit(*p
));
798 type
= TOK_PREPROC_ID
;
799 } else if (*p
== '{') {
801 while (*p
&& *p
!= '}') {
808 type
= TOK_PREPROC_ID
;
809 } else if (*p
== '[') {
811 line
+= 2; /* Skip the leading %[ */
813 while (lvl
&& (c
= *p
++)) {
825 p
= nasm_skip_string(p
)+1;
835 error(ERR_NONFATAL
, "unterminated %[ construct");
837 } else if (*p
== '?') {
838 type
= TOK_PREPROC_Q
; /* %? */
841 type
= TOK_PREPROC_QQ
; /* %?? */
844 } else if (isidchar(*p
) ||
845 ((*p
== '!' || *p
== '%' || *p
== '$') &&
850 while (isidchar(*p
));
851 type
= TOK_PREPROC_ID
;
857 } else if (isidstart(*p
) || (*p
== '$' && isidstart(p
[1]))) {
860 while (*p
&& isidchar(*p
))
862 } else if (*p
== '\'' || *p
== '"' || *p
== '`') {
867 p
= nasm_skip_string(p
);
872 error(ERR_WARNING
|ERR_PASS1
, "unterminated string");
873 /* Handling unterminated strings by UNV */
876 } else if (isnumstart(*p
)) {
878 bool is_float
= false;
894 if (!is_hex
&& (c
== 'e' || c
== 'E')) {
896 if (*p
== '+' || *p
== '-') {
897 /* e can only be followed by +/- if it is either a
898 prefixed hex number or a floating-point number */
902 } else if (c
== 'H' || c
== 'h' || c
== 'X' || c
== 'x') {
904 } else if (c
== 'P' || c
== 'p') {
906 if (*p
== '+' || *p
== '-')
908 } else if (isnumchar(c
) || c
== '_')
911 /* we need to deal with consequences of the legacy
912 parser, like "1.nolist" being two tokens
913 (TOK_NUMBER, TOK_ID) here; at least give it
914 a shot for now. In the future, we probably need
915 a flex-based scanner with proper pattern matching
916 to do it as well as it can be done. Nothing in
917 the world is going to help the person who wants
918 0x123.p16 interpreted as two tokens, though. */
923 if (nasm_isdigit(*r
) || (is_hex
&& nasm_isxdigit(*r
)) ||
924 (!is_hex
&& (*r
== 'e' || *r
== 'E')) ||
925 (*r
== 'p' || *r
== 'P')) {
929 break; /* Terminate the token */
933 p
--; /* Point to first character beyond number */
935 if (has_e
&& !is_hex
) {
936 /* 1e13 is floating-point, but 1e13h is not */
940 type
= is_float
? TOK_FLOAT
: TOK_NUMBER
;
941 } else if (nasm_isspace(*p
)) {
942 type
= TOK_WHITESPACE
;
944 while (*p
&& nasm_isspace(*p
))
947 * Whitespace just before end-of-line is discarded by
948 * pretending it's a comment; whitespace just before a
949 * comment gets lumped into the comment.
951 if (!*p
|| *p
== ';') {
956 } else if (*p
== ';') {
962 * Anything else is an operator of some kind. We check
963 * for all the double-character operators (>>, <<, //,
964 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
965 * else is a single-character operator.
968 if ((p
[0] == '>' && p
[1] == '>') ||
969 (p
[0] == '<' && p
[1] == '<') ||
970 (p
[0] == '/' && p
[1] == '/') ||
971 (p
[0] == '<' && p
[1] == '=') ||
972 (p
[0] == '>' && p
[1] == '=') ||
973 (p
[0] == '=' && p
[1] == '=') ||
974 (p
[0] == '!' && p
[1] == '=') ||
975 (p
[0] == '<' && p
[1] == '>') ||
976 (p
[0] == '&' && p
[1] == '&') ||
977 (p
[0] == '|' && p
[1] == '|') ||
978 (p
[0] == '^' && p
[1] == '^')) {
984 /* Handling unterminated string by UNV */
987 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
988 t->text[p-line] = *line;
992 if (type
!= TOK_COMMENT
) {
993 *tail
= t
= new_Token(NULL
, type
, line
, p
- line
);
1002 * this function allocates a new managed block of memory and
1003 * returns a pointer to the block. The managed blocks are
1004 * deleted only all at once by the delete_Blocks function.
1006 static void *new_Block(size_t size
)
1008 Blocks
*b
= &blocks
;
1010 /* first, get to the end of the linked list */
1013 /* now allocate the requested chunk */
1014 b
->chunk
= nasm_malloc(size
);
1016 /* now allocate a new block for the next request */
1017 b
->next
= nasm_malloc(sizeof(Blocks
));
1018 /* and initialize the contents of the new block */
1019 b
->next
->next
= NULL
;
1020 b
->next
->chunk
= NULL
;
1025 * this function deletes all managed blocks of memory
1027 static void delete_Blocks(void)
1029 Blocks
*a
, *b
= &blocks
;
1032 * keep in mind that the first block, pointed to by blocks
1033 * is a static and not dynamically allocated, so we don't
1038 nasm_free(b
->chunk
);
1047 * this function creates a new Token and passes a pointer to it
1048 * back to the caller. It sets the type and text elements, and
1049 * also the a.mac and next elements to NULL.
1051 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
1052 const char *text
, int txtlen
)
1057 if (freeTokens
== NULL
) {
1058 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
1059 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
1060 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
1061 freeTokens
[i
].next
= NULL
;
1064 freeTokens
= t
->next
;
1068 if (type
== TOK_WHITESPACE
|| text
== NULL
) {
1072 txtlen
= strlen(text
);
1073 t
->text
= nasm_malloc(txtlen
+1);
1074 memcpy(t
->text
, text
, txtlen
);
1075 t
->text
[txtlen
] = '\0';
1080 static Token
*delete_Token(Token
* t
)
1082 Token
*next
= t
->next
;
1084 t
->next
= freeTokens
;
1090 * Convert a line of tokens back into text.
1091 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1092 * will be transformed into ..@ctxnum.xxx
1094 static char *detoken(Token
* tlist
, bool expand_locals
)
1102 for (t
= tlist
; t
; t
= t
->next
) {
1103 if (t
->type
== TOK_PREPROC_ID
&& t
->text
[1] == '!') {
1104 char *p
= getenv(t
->text
+ 2);
1107 t
->text
= nasm_strdup(p
);
1111 /* Expand local macros here and not during preprocessing */
1112 if (expand_locals
&&
1113 t
->type
== TOK_PREPROC_ID
&& t
->text
&&
1114 t
->text
[0] == '%' && t
->text
[1] == '$') {
1115 Context
*ctx
= get_ctx(t
->text
, false);
1118 char *p
, *q
= t
->text
+ 2;
1120 q
+= strspn(q
, "$");
1121 snprintf(buffer
, sizeof(buffer
), "..@%"PRIu32
".", ctx
->number
);
1122 p
= nasm_strcat(buffer
, q
);
1127 if (t
->type
== TOK_WHITESPACE
) {
1129 } else if (t
->text
) {
1130 len
+= strlen(t
->text
);
1133 p
= line
= nasm_malloc(len
+ 1);
1134 for (t
= tlist
; t
; t
= t
->next
) {
1135 if (t
->type
== TOK_WHITESPACE
) {
1137 } else if (t
->text
) {
1148 * A scanner, suitable for use by the expression evaluator, which
1149 * operates on a line of Tokens. Expects a pointer to a pointer to
1150 * the first token in the line to be passed in as its private_data
1153 * FIX: This really needs to be unified with stdscan.
1155 static int ppscan(void *private_data
, struct tokenval
*tokval
)
1157 Token
**tlineptr
= private_data
;
1159 char ourcopy
[MAX_KEYWORD
+1], *p
, *r
, *s
;
1163 *tlineptr
= tline
? tline
->next
: NULL
;
1165 while (tline
&& (tline
->type
== TOK_WHITESPACE
||
1166 tline
->type
== TOK_COMMENT
));
1169 return tokval
->t_type
= TOKEN_EOS
;
1171 tokval
->t_charptr
= tline
->text
;
1173 if (tline
->text
[0] == '$' && !tline
->text
[1])
1174 return tokval
->t_type
= TOKEN_HERE
;
1175 if (tline
->text
[0] == '$' && tline
->text
[1] == '$' && !tline
->text
[2])
1176 return tokval
->t_type
= TOKEN_BASE
;
1178 if (tline
->type
== TOK_ID
) {
1179 p
= tokval
->t_charptr
= tline
->text
;
1181 tokval
->t_charptr
++;
1182 return tokval
->t_type
= TOKEN_ID
;
1185 for (r
= p
, s
= ourcopy
; *r
; r
++) {
1186 if (r
>= p
+MAX_KEYWORD
)
1187 return tokval
->t_type
= TOKEN_ID
; /* Not a keyword */
1188 *s
++ = nasm_tolower(*r
);
1191 /* right, so we have an identifier sitting in temp storage. now,
1192 * is it actually a register or instruction name, or what? */
1193 return nasm_token_hash(ourcopy
, tokval
);
1196 if (tline
->type
== TOK_NUMBER
) {
1198 tokval
->t_integer
= readnum(tline
->text
, &rn_error
);
1199 tokval
->t_charptr
= tline
->text
;
1201 return tokval
->t_type
= TOKEN_ERRNUM
;
1203 return tokval
->t_type
= TOKEN_NUM
;
1206 if (tline
->type
== TOK_FLOAT
) {
1207 return tokval
->t_type
= TOKEN_FLOAT
;
1210 if (tline
->type
== TOK_STRING
) {
1213 bq
= tline
->text
[0];
1214 tokval
->t_charptr
= tline
->text
;
1215 tokval
->t_inttwo
= nasm_unquote(tline
->text
, &ep
);
1217 if (ep
[0] != bq
|| ep
[1] != '\0')
1218 return tokval
->t_type
= TOKEN_ERRSTR
;
1220 return tokval
->t_type
= TOKEN_STR
;
1223 if (tline
->type
== TOK_OTHER
) {
1224 if (!strcmp(tline
->text
, "<<"))
1225 return tokval
->t_type
= TOKEN_SHL
;
1226 if (!strcmp(tline
->text
, ">>"))
1227 return tokval
->t_type
= TOKEN_SHR
;
1228 if (!strcmp(tline
->text
, "//"))
1229 return tokval
->t_type
= TOKEN_SDIV
;
1230 if (!strcmp(tline
->text
, "%%"))
1231 return tokval
->t_type
= TOKEN_SMOD
;
1232 if (!strcmp(tline
->text
, "=="))
1233 return tokval
->t_type
= TOKEN_EQ
;
1234 if (!strcmp(tline
->text
, "<>"))
1235 return tokval
->t_type
= TOKEN_NE
;
1236 if (!strcmp(tline
->text
, "!="))
1237 return tokval
->t_type
= TOKEN_NE
;
1238 if (!strcmp(tline
->text
, "<="))
1239 return tokval
->t_type
= TOKEN_LE
;
1240 if (!strcmp(tline
->text
, ">="))
1241 return tokval
->t_type
= TOKEN_GE
;
1242 if (!strcmp(tline
->text
, "&&"))
1243 return tokval
->t_type
= TOKEN_DBL_AND
;
1244 if (!strcmp(tline
->text
, "^^"))
1245 return tokval
->t_type
= TOKEN_DBL_XOR
;
1246 if (!strcmp(tline
->text
, "||"))
1247 return tokval
->t_type
= TOKEN_DBL_OR
;
1251 * We have no other options: just return the first character of
1254 return tokval
->t_type
= tline
->text
[0];
1258 * Compare a string to the name of an existing macro; this is a
1259 * simple wrapper which calls either strcmp or nasm_stricmp
1260 * depending on the value of the `casesense' parameter.
1262 static int mstrcmp(const char *p
, const char *q
, bool casesense
)
1264 return casesense
? strcmp(p
, q
) : nasm_stricmp(p
, q
);
1268 * Compare a string to the name of an existing macro; this is a
1269 * simple wrapper which calls either strcmp or nasm_stricmp
1270 * depending on the value of the `casesense' parameter.
1272 static int mmemcmp(const char *p
, const char *q
, size_t l
, bool casesense
)
1274 return casesense
? memcmp(p
, q
, l
) : nasm_memicmp(p
, q
, l
);
1278 * Return the Context structure associated with a %$ token. Return
1279 * NULL, having _already_ reported an error condition, if the
1280 * context stack isn't deep enough for the supplied number of $
1282 * If all_contexts == true, contexts that enclose current are
1283 * also scanned for such smacro, until it is found; if not -
1284 * only the context that directly results from the number of $'s
1285 * in variable's name.
1287 static Context
*get_ctx(const char *name
, bool all_contexts
)
1293 if (!name
|| name
[0] != '%' || name
[1] != '$')
1297 error(ERR_NONFATAL
, "`%s': context stack is empty", name
);
1301 for (i
= strspn(name
+ 2, "$"), ctx
= cstk
; (i
> 0) && ctx
; i
--) {
1303 /* i--; Lino - 02/25/02 */
1306 error(ERR_NONFATAL
, "`%s': context stack is only"
1307 " %d level%s deep", name
, i
- 1, (i
== 2 ? "" : "s"));
1314 /* Search for this smacro in found context */
1315 m
= hash_findix(&ctx
->localmac
, name
);
1317 if (!mstrcmp(m
->name
, name
, m
->casesense
))
1328 * Check to see if a file is already in a string list
1330 static bool in_list(const StrList
*list
, const char *str
)
1333 if (!strcmp(list
->str
, str
))
1341 * Open an include file. This routine must always return a valid
1342 * file pointer if it returns - it's responsible for throwing an
1343 * ERR_FATAL and bombing out completely if not. It should also try
1344 * the include path one by one until it finds the file or reaches
1345 * the end of the path.
1347 static FILE *inc_fopen(const char *file
, StrList
**dhead
, StrList
***dtail
,
1352 IncPath
*ip
= ipath
;
1353 int len
= strlen(file
);
1354 size_t prefix_len
= 0;
1358 sl
= nasm_malloc(prefix_len
+len
+1+sizeof sl
->next
);
1359 memcpy(sl
->str
, prefix
, prefix_len
);
1360 memcpy(sl
->str
+prefix_len
, file
, len
+1);
1361 fp
= fopen(sl
->str
, "r");
1362 if (fp
&& dhead
&& !in_list(*dhead
, sl
->str
)) {
1380 prefix_len
= strlen(prefix
);
1382 /* -MG given and file not found */
1383 if (dhead
&& !in_list(*dhead
, file
)) {
1384 sl
= nasm_malloc(len
+1+sizeof sl
->next
);
1386 strcpy(sl
->str
, file
);
1394 error(ERR_FATAL
, "unable to open include file `%s'", file
);
1395 return NULL
; /* never reached - placate compilers */
1399 * Determine if we should warn on defining a single-line macro of
1400 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1401 * return true if _any_ single-line macro of that name is defined.
1402 * Otherwise, will return true if a single-line macro with either
1403 * `nparam' or no parameters is defined.
1405 * If a macro with precisely the right number of parameters is
1406 * defined, or nparam is -1, the address of the definition structure
1407 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1408 * is NULL, no action will be taken regarding its contents, and no
1411 * Note that this is also called with nparam zero to resolve
1414 * If you already know which context macro belongs to, you can pass
1415 * the context pointer as first parameter; if you won't but name begins
1416 * with %$ the context will be automatically computed. If all_contexts
1417 * is true, macro will be searched in outer contexts as well.
1420 smacro_defined(Context
* ctx
, const char *name
, int nparam
, SMacro
** defn
,
1423 struct hash_table
*smtbl
;
1427 smtbl
= &ctx
->localmac
;
1428 } else if (name
[0] == '%' && name
[1] == '$') {
1430 ctx
= get_ctx(name
, false);
1432 return false; /* got to return _something_ */
1433 smtbl
= &ctx
->localmac
;
1437 m
= (SMacro
*) hash_findix(smtbl
, name
);
1440 if (!mstrcmp(m
->name
, name
, m
->casesense
&& nocase
) &&
1441 (nparam
<= 0 || m
->nparam
== 0 || nparam
== (int) m
->nparam
)) {
1443 if (nparam
== (int) m
->nparam
|| nparam
== -1)
1457 * Count and mark off the parameters in a multi-line macro call.
1458 * This is called both from within the multi-line macro expansion
1459 * code, and also to mark off the default parameters when provided
1460 * in a %macro definition line.
1462 static void count_mmac_params(Token
* t
, int *nparam
, Token
*** params
)
1464 int paramsize
, brace
;
1466 *nparam
= paramsize
= 0;
1469 /* +1: we need space for the final NULL */
1470 if (*nparam
+1 >= paramsize
) {
1471 paramsize
+= PARAM_DELTA
;
1472 *params
= nasm_realloc(*params
, sizeof(**params
) * paramsize
);
1476 if (tok_is_(t
, "{"))
1478 (*params
)[(*nparam
)++] = t
;
1479 while (tok_isnt_(t
, brace
? "}" : ","))
1481 if (t
) { /* got a comma/brace */
1485 * Now we've found the closing brace, look further
1489 if (tok_isnt_(t
, ",")) {
1491 "braces do not enclose all of macro parameter");
1492 while (tok_isnt_(t
, ","))
1496 t
= t
->next
; /* eat the comma */
1503 * Determine whether one of the various `if' conditions is true or
1506 * We must free the tline we get passed.
1508 static bool if_condition(Token
* tline
, enum preproc_token ct
)
1510 enum pp_conditional i
= PP_COND(ct
);
1512 Token
*t
, *tt
, **tptr
, *origline
;
1513 struct tokenval tokval
;
1515 enum pp_token_type needtype
;
1521 j
= false; /* have we matched yet? */
1526 if (tline
->type
!= TOK_ID
) {
1528 "`%s' expects context identifiers", pp_directives
[ct
]);
1529 free_tlist(origline
);
1532 if (cstk
&& cstk
->name
&& !nasm_stricmp(tline
->text
, cstk
->name
))
1534 tline
= tline
->next
;
1539 j
= false; /* have we matched yet? */
1542 if (!tline
|| (tline
->type
!= TOK_ID
&&
1543 (tline
->type
!= TOK_PREPROC_ID
||
1544 tline
->text
[1] != '$'))) {
1546 "`%s' expects macro identifiers", pp_directives
[ct
]);
1549 if (smacro_defined(NULL
, tline
->text
, 0, NULL
, true))
1551 tline
= tline
->next
;
1557 tline
= expand_smacro(tline
);
1559 while (tok_isnt_(tt
, ","))
1563 "`%s' expects two comma-separated arguments",
1568 j
= true; /* assume equality unless proved not */
1569 while ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) && tt
) {
1570 if (tt
->type
== TOK_OTHER
&& !strcmp(tt
->text
, ",")) {
1571 error(ERR_NONFATAL
, "`%s': more than one comma on line",
1575 if (t
->type
== TOK_WHITESPACE
) {
1579 if (tt
->type
== TOK_WHITESPACE
) {
1583 if (tt
->type
!= t
->type
) {
1584 j
= false; /* found mismatching tokens */
1587 /* When comparing strings, need to unquote them first */
1588 if (t
->type
== TOK_STRING
) {
1589 size_t l1
= nasm_unquote(t
->text
, NULL
);
1590 size_t l2
= nasm_unquote(tt
->text
, NULL
);
1596 if (mmemcmp(t
->text
, tt
->text
, l1
, i
== PPC_IFIDN
)) {
1600 } else if (mstrcmp(tt
->text
, t
->text
, i
== PPC_IFIDN
) != 0) {
1601 j
= false; /* found mismatching tokens */
1608 if ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) || tt
)
1609 j
= false; /* trailing gunk on one end or other */
1615 MMacro searching
, *mmac
;
1617 tline
= tline
->next
;
1619 tline
= expand_id(tline
);
1620 if (!tok_type_(tline
, TOK_ID
)) {
1622 "`%s' expects a macro name", pp_directives
[ct
]);
1625 searching
.name
= nasm_strdup(tline
->text
);
1626 searching
.casesense
= true;
1627 searching
.plus
= false;
1628 searching
.nolist
= false;
1629 searching
.in_progress
= 0;
1630 searching
.rep_nest
= NULL
;
1631 searching
.nparam_min
= 0;
1632 searching
.nparam_max
= INT_MAX
;
1633 tline
= expand_smacro(tline
->next
);
1636 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
1638 "`%s' expects a parameter count or nothing",
1641 searching
.nparam_min
= searching
.nparam_max
=
1642 readnum(tline
->text
, &j
);
1645 "unable to parse parameter count `%s'",
1648 if (tline
&& tok_is_(tline
->next
, "-")) {
1649 tline
= tline
->next
->next
;
1650 if (tok_is_(tline
, "*"))
1651 searching
.nparam_max
= INT_MAX
;
1652 else if (!tok_type_(tline
, TOK_NUMBER
))
1654 "`%s' expects a parameter count after `-'",
1657 searching
.nparam_max
= readnum(tline
->text
, &j
);
1660 "unable to parse parameter count `%s'",
1662 if (searching
.nparam_min
> searching
.nparam_max
)
1664 "minimum parameter count exceeds maximum");
1667 if (tline
&& tok_is_(tline
->next
, "+")) {
1668 tline
= tline
->next
;
1669 searching
.plus
= true;
1671 mmac
= (MMacro
*) hash_findix(&mmacros
, searching
.name
);
1673 if (!strcmp(mmac
->name
, searching
.name
) &&
1674 (mmac
->nparam_min
<= searching
.nparam_max
1676 && (searching
.nparam_min
<= mmac
->nparam_max
1683 if(tline
&& tline
->next
)
1684 error(ERR_WARNING
|ERR_PASS1
,
1685 "trailing garbage after %%ifmacro ignored");
1686 nasm_free(searching
.name
);
1695 needtype
= TOK_NUMBER
;
1698 needtype
= TOK_STRING
;
1702 t
= tline
= expand_smacro(tline
);
1704 while (tok_type_(t
, TOK_WHITESPACE
) ||
1705 (needtype
== TOK_NUMBER
&&
1706 tok_type_(t
, TOK_OTHER
) &&
1707 (t
->text
[0] == '-' || t
->text
[0] == '+') &&
1711 j
= tok_type_(t
, needtype
);
1715 t
= tline
= expand_smacro(tline
);
1716 while (tok_type_(t
, TOK_WHITESPACE
))
1721 t
= t
->next
; /* Skip the actual token */
1722 while (tok_type_(t
, TOK_WHITESPACE
))
1724 j
= !t
; /* Should be nothing left */
1729 t
= tline
= expand_smacro(tline
);
1730 while (tok_type_(t
, TOK_WHITESPACE
))
1733 j
= !t
; /* Should be empty */
1737 t
= tline
= expand_smacro(tline
);
1739 tokval
.t_type
= TOKEN_INVALID
;
1740 evalresult
= evaluate(ppscan
, tptr
, &tokval
,
1741 NULL
, pass
| CRITICAL
, error
, NULL
);
1745 error(ERR_WARNING
|ERR_PASS1
,
1746 "trailing garbage after expression ignored");
1747 if (!is_simple(evalresult
)) {
1749 "non-constant value given to `%s'", pp_directives
[ct
]);
1752 j
= reloc_value(evalresult
) != 0;
1757 "preprocessor directive `%s' not yet implemented",
1762 free_tlist(origline
);
1763 return j
^ PP_NEGATIVE(ct
);
1766 free_tlist(origline
);
1771 * Common code for defining an smacro
1773 static bool define_smacro(Context
*ctx
, char *mname
, bool casesense
,
1774 int nparam
, Token
*expansion
)
1776 SMacro
*smac
, **smhead
;
1777 struct hash_table
*smtbl
;
1779 if (smacro_defined(ctx
, mname
, nparam
, &smac
, casesense
)) {
1781 error(ERR_WARNING
|ERR_PASS1
,
1782 "single-line macro `%s' defined both with and"
1783 " without parameters", mname
);
1785 /* Some instances of the old code considered this a failure,
1786 some others didn't. What is the right thing to do here? */
1787 free_tlist(expansion
);
1788 return false; /* Failure */
1791 * We're redefining, so we have to take over an
1792 * existing SMacro structure. This means freeing
1793 * what was already in it.
1795 nasm_free(smac
->name
);
1796 free_tlist(smac
->expansion
);
1799 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1800 smhead
= (SMacro
**) hash_findi_add(smtbl
, mname
);
1801 smac
= nasm_malloc(sizeof(SMacro
));
1802 smac
->next
= *smhead
;
1805 smac
->name
= nasm_strdup(mname
);
1806 smac
->casesense
= casesense
;
1807 smac
->nparam
= nparam
;
1808 smac
->expansion
= expansion
;
1809 smac
->in_progress
= false;
1810 return true; /* Success */
1814 * Undefine an smacro
1816 static void undef_smacro(Context
*ctx
, const char *mname
)
1818 SMacro
**smhead
, *s
, **sp
;
1819 struct hash_table
*smtbl
;
1821 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1822 smhead
= (SMacro
**)hash_findi(smtbl
, mname
, NULL
);
1826 * We now have a macro name... go hunt for it.
1829 while ((s
= *sp
) != NULL
) {
1830 if (!mstrcmp(s
->name
, mname
, s
->casesense
)) {
1833 free_tlist(s
->expansion
);
1843 * Parse a mmacro specification.
1845 static bool parse_mmacro_spec(Token
*tline
, MMacro
*def
, const char *directive
)
1849 tline
= tline
->next
;
1851 tline
= expand_id(tline
);
1852 if (!tok_type_(tline
, TOK_ID
)) {
1853 error(ERR_NONFATAL
, "`%s' expects a macro name", directive
);
1857 def
->name
= nasm_strdup(tline
->text
);
1859 def
->nolist
= false;
1860 def
->in_progress
= 0;
1861 def
->rep_nest
= NULL
;
1862 def
->nparam_min
= 0;
1863 def
->nparam_max
= 0;
1865 tline
= expand_smacro(tline
->next
);
1867 if (!tok_type_(tline
, TOK_NUMBER
)) {
1868 error(ERR_NONFATAL
, "`%s' expects a parameter count", directive
);
1870 def
->nparam_min
= def
->nparam_max
=
1871 readnum(tline
->text
, &err
);
1874 "unable to parse parameter count `%s'", tline
->text
);
1876 if (tline
&& tok_is_(tline
->next
, "-")) {
1877 tline
= tline
->next
->next
;
1878 if (tok_is_(tline
, "*")) {
1879 def
->nparam_max
= INT_MAX
;
1880 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
1882 "`%s' expects a parameter count after `-'", directive
);
1884 def
->nparam_max
= readnum(tline
->text
, &err
);
1886 error(ERR_NONFATAL
, "unable to parse parameter count `%s'",
1889 if (def
->nparam_min
> def
->nparam_max
) {
1890 error(ERR_NONFATAL
, "minimum parameter count exceeds maximum");
1894 if (tline
&& tok_is_(tline
->next
, "+")) {
1895 tline
= tline
->next
;
1898 if (tline
&& tok_type_(tline
->next
, TOK_ID
) &&
1899 !nasm_stricmp(tline
->next
->text
, ".nolist")) {
1900 tline
= tline
->next
;
1905 * Handle default parameters.
1907 if (tline
&& tline
->next
) {
1908 def
->dlist
= tline
->next
;
1910 count_mmac_params(def
->dlist
, &def
->ndefs
, &def
->defaults
);
1913 def
->defaults
= NULL
;
1915 def
->expansion
= NULL
;
1918 def
->ndefs
> def
->nparam_max
- def
->nparam_min
&&
1920 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MDP
,
1921 "too many default macro parameters");
1928 * Decode a size directive
1930 static int parse_size(const char *str
) {
1931 static const char *size_names
[] =
1932 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
1933 static const int sizes
[] =
1934 { 0, 1, 4, 16, 8, 10, 2, 32 };
1936 return sizes
[bsii(str
, size_names
, elements(size_names
))+1];
1940 * find and process preprocessor directive in passed line
1941 * Find out if a line contains a preprocessor directive, and deal
1944 * If a directive _is_ found, it is the responsibility of this routine
1945 * (and not the caller) to free_tlist() the line.
1947 * @param tline a pointer to the current tokeninzed line linked list
1948 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
1951 static int do_directive(Token
* tline
)
1953 enum preproc_token i
;
1961 char *p
, *pp
, *mname
;
1965 MMacro
*mmac
, **mmhead
;
1966 Token
*t
, *tt
, *param_start
, *macro_start
, *last
, **tptr
, *origline
;
1968 struct tokenval tokval
;
1970 MMacro
*tmp_defining
; /* Used when manipulating rep_nest */
1978 if (!tline
|| !tok_type_(tline
, TOK_PREPROC_ID
) ||
1979 (tline
->text
[1] == '%' || tline
->text
[1] == '$'
1980 || tline
->text
[1] == '!'))
1981 return NO_DIRECTIVE_FOUND
;
1983 i
= pp_token_hash(tline
->text
);
1986 * If we're in a non-emitting branch of a condition construct,
1987 * or walking to the end of an already terminated %rep block,
1988 * we should ignore all directives except for condition
1991 if (((istk
->conds
&& !emitting(istk
->conds
->state
)) ||
1992 (istk
->mstk
&& !istk
->mstk
->in_progress
)) && !is_condition(i
)) {
1993 return NO_DIRECTIVE_FOUND
;
1997 * If we're defining a macro or reading a %rep block, we should
1998 * ignore all directives except for %macro/%imacro (which nest),
1999 * %endm/%endmacro, and (only if we're in a %rep block) %endrep.
2000 * If we're in a %rep block, another %rep nests, so should be let through.
2002 if (defining
&& i
!= PP_MACRO
&& i
!= PP_IMACRO
&&
2003 i
!= PP_ENDMACRO
&& i
!= PP_ENDM
&&
2004 (defining
->name
|| (i
!= PP_ENDREP
&& i
!= PP_REP
))) {
2005 return NO_DIRECTIVE_FOUND
;
2009 if (i
== PP_MACRO
|| i
== PP_IMACRO
) {
2011 return NO_DIRECTIVE_FOUND
;
2012 } else if (nested_mac_count
> 0) {
2013 if (i
== PP_ENDMACRO
) {
2015 return NO_DIRECTIVE_FOUND
;
2018 if (!defining
->name
) {
2021 return NO_DIRECTIVE_FOUND
;
2022 } else if (nested_rep_count
> 0) {
2023 if (i
== PP_ENDREP
) {
2025 return NO_DIRECTIVE_FOUND
;
2033 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
2035 return NO_DIRECTIVE_FOUND
; /* didn't get it */
2038 /* Directive to tell NASM what the default stack size is. The
2039 * default is for a 16-bit stack, and this can be overriden with
2041 * the following form:
2043 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2045 tline
= tline
->next
;
2046 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2047 tline
= tline
->next
;
2048 if (!tline
|| tline
->type
!= TOK_ID
) {
2049 error(ERR_NONFATAL
, "`%%stacksize' missing size parameter");
2050 free_tlist(origline
);
2051 return DIRECTIVE_FOUND
;
2053 if (nasm_stricmp(tline
->text
, "flat") == 0) {
2054 /* All subsequent ARG directives are for a 32-bit stack */
2056 StackPointer
= "ebp";
2059 } else if (nasm_stricmp(tline
->text
, "flat64") == 0) {
2060 /* All subsequent ARG directives are for a 64-bit stack */
2062 StackPointer
= "rbp";
2065 } else if (nasm_stricmp(tline
->text
, "large") == 0) {
2066 /* All subsequent ARG directives are for a 16-bit stack,
2067 * far function call.
2070 StackPointer
= "bp";
2073 } else if (nasm_stricmp(tline
->text
, "small") == 0) {
2074 /* All subsequent ARG directives are for a 16-bit stack,
2075 * far function call. We don't support near functions.
2078 StackPointer
= "bp";
2082 error(ERR_NONFATAL
, "`%%stacksize' invalid size type");
2083 free_tlist(origline
);
2084 return DIRECTIVE_FOUND
;
2086 free_tlist(origline
);
2087 return DIRECTIVE_FOUND
;
2090 /* TASM like ARG directive to define arguments to functions, in
2091 * the following form:
2093 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2097 char *arg
, directive
[256];
2098 int size
= StackSize
;
2100 /* Find the argument name */
2101 tline
= tline
->next
;
2102 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2103 tline
= tline
->next
;
2104 if (!tline
|| tline
->type
!= TOK_ID
) {
2105 error(ERR_NONFATAL
, "`%%arg' missing argument parameter");
2106 free_tlist(origline
);
2107 return DIRECTIVE_FOUND
;
2111 /* Find the argument size type */
2112 tline
= tline
->next
;
2113 if (!tline
|| tline
->type
!= TOK_OTHER
2114 || tline
->text
[0] != ':') {
2116 "Syntax error processing `%%arg' directive");
2117 free_tlist(origline
);
2118 return DIRECTIVE_FOUND
;
2120 tline
= tline
->next
;
2121 if (!tline
|| tline
->type
!= TOK_ID
) {
2122 error(ERR_NONFATAL
, "`%%arg' missing size type parameter");
2123 free_tlist(origline
);
2124 return DIRECTIVE_FOUND
;
2127 /* Allow macro expansion of type parameter */
2128 tt
= tokenize(tline
->text
);
2129 tt
= expand_smacro(tt
);
2130 size
= parse_size(tt
->text
);
2133 "Invalid size type for `%%arg' missing directive");
2135 free_tlist(origline
);
2136 return DIRECTIVE_FOUND
;
2140 /* Round up to even stack slots */
2141 size
= (size
+StackSize
-1) & ~(StackSize
-1);
2143 /* Now define the macro for the argument */
2144 snprintf(directive
, sizeof(directive
), "%%define %s (%s+%d)",
2145 arg
, StackPointer
, offset
);
2146 do_directive(tokenize(directive
));
2149 /* Move to the next argument in the list */
2150 tline
= tline
->next
;
2151 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2152 tline
= tline
->next
;
2153 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2155 free_tlist(origline
);
2156 return DIRECTIVE_FOUND
;
2159 /* TASM like LOCAL directive to define local variables for a
2160 * function, in the following form:
2162 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2164 * The '= LocalSize' at the end is ignored by NASM, but is
2165 * required by TASM to define the local parameter size (and used
2166 * by the TASM macro package).
2168 offset
= LocalOffset
;
2170 char *local
, directive
[256];
2171 int size
= StackSize
;
2173 /* Find the argument name */
2174 tline
= tline
->next
;
2175 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2176 tline
= tline
->next
;
2177 if (!tline
|| tline
->type
!= TOK_ID
) {
2179 "`%%local' missing argument parameter");
2180 free_tlist(origline
);
2181 return DIRECTIVE_FOUND
;
2183 local
= tline
->text
;
2185 /* Find the argument size type */
2186 tline
= tline
->next
;
2187 if (!tline
|| tline
->type
!= TOK_OTHER
2188 || tline
->text
[0] != ':') {
2190 "Syntax error processing `%%local' directive");
2191 free_tlist(origline
);
2192 return DIRECTIVE_FOUND
;
2194 tline
= tline
->next
;
2195 if (!tline
|| tline
->type
!= TOK_ID
) {
2197 "`%%local' missing size type parameter");
2198 free_tlist(origline
);
2199 return DIRECTIVE_FOUND
;
2202 /* Allow macro expansion of type parameter */
2203 tt
= tokenize(tline
->text
);
2204 tt
= expand_smacro(tt
);
2205 size
= parse_size(tt
->text
);
2208 "Invalid size type for `%%local' missing directive");
2210 free_tlist(origline
);
2211 return DIRECTIVE_FOUND
;
2215 /* Round up to even stack slots */
2216 size
= (size
+StackSize
-1) & ~(StackSize
-1);
2218 offset
+= size
; /* Negative offset, increment before */
2220 /* Now define the macro for the argument */
2221 snprintf(directive
, sizeof(directive
), "%%define %s (%s-%d)",
2222 local
, StackPointer
, offset
);
2223 do_directive(tokenize(directive
));
2225 /* Now define the assign to setup the enter_c macro correctly */
2226 snprintf(directive
, sizeof(directive
),
2227 "%%assign %%$localsize %%$localsize+%d", size
);
2228 do_directive(tokenize(directive
));
2230 /* Move to the next argument in the list */
2231 tline
= tline
->next
;
2232 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2233 tline
= tline
->next
;
2234 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2235 LocalOffset
= offset
;
2236 free_tlist(origline
);
2237 return DIRECTIVE_FOUND
;
2241 error(ERR_WARNING
|ERR_PASS1
,
2242 "trailing garbage after `%%clear' ignored");
2245 free_tlist(origline
);
2246 return DIRECTIVE_FOUND
;
2249 t
= tline
->next
= expand_smacro(tline
->next
);
2251 if (!t
|| (t
->type
!= TOK_STRING
&&
2252 t
->type
!= TOK_INTERNAL_STRING
)) {
2253 error(ERR_NONFATAL
, "`%%depend' expects a file name");
2254 free_tlist(origline
);
2255 return DIRECTIVE_FOUND
; /* but we did _something_ */
2258 error(ERR_WARNING
|ERR_PASS1
,
2259 "trailing garbage after `%%depend' ignored");
2261 if (t
->type
!= TOK_INTERNAL_STRING
)
2262 nasm_unquote(p
, NULL
);
2263 if (dephead
&& !in_list(*dephead
, p
)) {
2264 StrList
*sl
= nasm_malloc(strlen(p
)+1+sizeof sl
->next
);
2268 deptail
= &sl
->next
;
2270 free_tlist(origline
);
2271 return DIRECTIVE_FOUND
;
2274 t
= tline
->next
= expand_smacro(tline
->next
);
2277 if (!t
|| (t
->type
!= TOK_STRING
&&
2278 t
->type
!= TOK_INTERNAL_STRING
)) {
2279 error(ERR_NONFATAL
, "`%%include' expects a file name");
2280 free_tlist(origline
);
2281 return DIRECTIVE_FOUND
; /* but we did _something_ */
2284 error(ERR_WARNING
|ERR_PASS1
,
2285 "trailing garbage after `%%include' ignored");
2287 if (t
->type
!= TOK_INTERNAL_STRING
)
2288 nasm_unquote(p
, NULL
);
2289 inc
= nasm_malloc(sizeof(Include
));
2292 inc
->fp
= inc_fopen(p
, dephead
, &deptail
, pass
== 0);
2294 /* -MG given but file not found */
2297 inc
->fname
= src_set_fname(nasm_strdup(p
));
2298 inc
->lineno
= src_set_linnum(0);
2300 inc
->expansion
= NULL
;
2303 list
->uplevel(LIST_INCLUDE
);
2305 free_tlist(origline
);
2306 return DIRECTIVE_FOUND
;
2310 static macros_t
*use_pkg
;
2311 const char *pkg_macro
;
2313 tline
= tline
->next
;
2315 tline
= expand_id(tline
);
2317 if (!tline
|| (tline
->type
!= TOK_STRING
&&
2318 tline
->type
!= TOK_INTERNAL_STRING
&&
2319 tline
->type
!= TOK_ID
)) {
2320 error(ERR_NONFATAL
, "`%%use' expects a package name");
2321 free_tlist(origline
);
2322 return DIRECTIVE_FOUND
; /* but we did _something_ */
2325 error(ERR_WARNING
|ERR_PASS1
,
2326 "trailing garbage after `%%use' ignored");
2327 if (tline
->type
== TOK_STRING
)
2328 nasm_unquote(tline
->text
, NULL
);
2329 use_pkg
= nasm_stdmac_find_package(tline
->text
);
2331 error(ERR_NONFATAL
, "unknown `%%use' package: %s", tline
->text
);
2332 /* The first string will be <%define>__USE_*__ */
2333 pkg_macro
= (char *)use_pkg
+ 1;
2334 if (!smacro_defined(NULL
, pkg_macro
, 0, NULL
, true)) {
2335 /* Not already included, go ahead and include it */
2336 stdmacpos
= use_pkg
;
2338 free_tlist(origline
);
2339 return DIRECTIVE_FOUND
;
2344 tline
= tline
->next
;
2346 tline
= expand_id(tline
);
2348 if (!tok_type_(tline
, TOK_ID
)) {
2349 error(ERR_NONFATAL
, "`%s' expects a context identifier",
2351 free_tlist(origline
);
2352 return DIRECTIVE_FOUND
; /* but we did _something_ */
2355 error(ERR_WARNING
|ERR_PASS1
,
2356 "trailing garbage after `%s' ignored",
2358 p
= nasm_strdup(tline
->text
);
2360 p
= NULL
; /* Anonymous */
2364 ctx
= nasm_malloc(sizeof(Context
));
2366 hash_init(&ctx
->localmac
, HASH_SMALL
);
2368 ctx
->number
= unique
++;
2373 error(ERR_NONFATAL
, "`%s': context stack is empty",
2375 } else if (i
== PP_POP
) {
2376 if (p
&& (!cstk
->name
|| nasm_stricmp(p
, cstk
->name
)))
2377 error(ERR_NONFATAL
, "`%%pop' in wrong context: %s, "
2379 cstk
->name
? cstk
->name
: "anonymous", p
);
2384 nasm_free(cstk
->name
);
2390 free_tlist(origline
);
2391 return DIRECTIVE_FOUND
;
2393 severity
= ERR_FATAL
|ERR_NO_SEVERITY
;
2396 severity
= ERR_NONFATAL
|ERR_NO_SEVERITY
;
2399 severity
= ERR_WARNING
|ERR_NO_SEVERITY
|ERR_WARN_USER
;
2404 /* Only error out if this is the final pass */
2405 if (pass
!= 2 && i
!= PP_FATAL
)
2406 return DIRECTIVE_FOUND
;
2408 tline
->next
= expand_smacro(tline
->next
);
2409 tline
= tline
->next
;
2411 t
= tline
? tline
->next
: NULL
;
2413 if (tok_type_(tline
, TOK_STRING
) && !t
) {
2414 /* The line contains only a quoted string */
2416 nasm_unquote(p
, NULL
);
2417 error(severity
, "%s: %s", pp_directives
[i
], p
);
2419 /* Not a quoted string, or more than a quoted string */
2420 p
= detoken(tline
, false);
2421 error(severity
, "%s: %s", pp_directives
[i
], p
);
2424 free_tlist(origline
);
2425 return DIRECTIVE_FOUND
;
2429 if (istk
->conds
&& !emitting(istk
->conds
->state
))
2432 j
= if_condition(tline
->next
, i
);
2433 tline
->next
= NULL
; /* it got freed */
2434 j
= j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2436 cond
= nasm_malloc(sizeof(Cond
));
2437 cond
->next
= istk
->conds
;
2440 free_tlist(origline
);
2441 return DIRECTIVE_FOUND
;
2445 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2446 switch(istk
->conds
->state
) {
2448 istk
->conds
->state
= COND_DONE
;
2455 case COND_ELSE_TRUE
:
2456 case COND_ELSE_FALSE
:
2457 error_precond(ERR_WARNING
|ERR_PASS1
,
2458 "`%%elif' after `%%else' ignored");
2459 istk
->conds
->state
= COND_NEVER
;
2464 * IMPORTANT: In the case of %if, we will already have
2465 * called expand_mmac_params(); however, if we're
2466 * processing an %elif we must have been in a
2467 * non-emitting mode, which would have inhibited
2468 * the normal invocation of expand_indirect() and
2469 * expand_mmac_params(). Therefore, we have to do it
2472 t
= expand_indirect(tline
->next
,0);
2473 t
= expand_mmac_params(t
);
2474 j
= if_condition(expand_mmac_params(t
), i
);
2475 tline
->next
= NULL
; /* it got freed */
2476 istk
->conds
->state
=
2477 j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2480 free_tlist(origline
);
2481 return DIRECTIVE_FOUND
;
2485 error_precond(ERR_WARNING
|ERR_PASS1
,
2486 "trailing garbage after `%%else' ignored");
2488 error(ERR_FATAL
, "`%%else': no matching `%%if'");
2489 switch(istk
->conds
->state
) {
2492 istk
->conds
->state
= COND_ELSE_FALSE
;
2499 istk
->conds
->state
= COND_ELSE_TRUE
;
2502 case COND_ELSE_TRUE
:
2503 case COND_ELSE_FALSE
:
2504 error_precond(ERR_WARNING
|ERR_PASS1
,
2505 "`%%else' after `%%else' ignored.");
2506 istk
->conds
->state
= COND_NEVER
;
2509 free_tlist(origline
);
2510 return DIRECTIVE_FOUND
;
2514 error_precond(ERR_WARNING
|ERR_PASS1
,
2515 "trailing garbage after `%%endif' ignored");
2517 error(ERR_FATAL
, "`%%endif': no matching `%%if'");
2519 istk
->conds
= cond
->next
;
2521 free_tlist(origline
);
2522 return DIRECTIVE_FOUND
;
2528 "`%%%smacro': already defining a macro",
2529 (i
== PP_IMACRO
? "i" : ""));
2530 return DIRECTIVE_FOUND
;
2532 defining
= nasm_malloc(sizeof(MMacro
));
2533 defining
->casesense
= (i
== PP_MACRO
);
2534 if (!parse_mmacro_spec(tline
, defining
, pp_directives
[i
])) {
2535 nasm_free(defining
);
2537 return DIRECTIVE_FOUND
;
2540 mmac
= (MMacro
*) hash_findix(&mmacros
, defining
->name
);
2542 if (!strcmp(mmac
->name
, defining
->name
) &&
2543 (mmac
->nparam_min
<= defining
->nparam_max
2545 && (defining
->nparam_min
<= mmac
->nparam_max
2547 error(ERR_WARNING
|ERR_PASS1
,
2548 "redefining multi-line macro `%s'", defining
->name
);
2549 return DIRECTIVE_FOUND
;
2553 free_tlist(origline
);
2554 return DIRECTIVE_FOUND
;
2558 if (! (defining
&& defining
->name
)) {
2559 error(ERR_NONFATAL
, "`%s': not defining a macro", tline
->text
);
2560 return DIRECTIVE_FOUND
;
2562 mmhead
= (MMacro
**) hash_findi_add(&mmacros
, defining
->name
);
2563 defining
->next
= *mmhead
;
2566 free_tlist(origline
);
2567 return DIRECTIVE_FOUND
;
2575 spec
.casesense
= (i
== PP_UNMACRO
);
2576 if (!parse_mmacro_spec(tline
, &spec
, pp_directives
[i
])) {
2577 return DIRECTIVE_FOUND
;
2579 mmac_p
= (MMacro
**) hash_findi(&mmacros
, spec
.name
, NULL
);
2580 while (mmac_p
&& *mmac_p
) {
2582 if (mmac
->casesense
== spec
.casesense
&&
2583 !mstrcmp(mmac
->name
, spec
.name
, spec
.casesense
) &&
2584 mmac
->nparam_min
== spec
.nparam_min
&&
2585 mmac
->nparam_max
== spec
.nparam_max
&&
2586 mmac
->plus
== spec
.plus
) {
2587 *mmac_p
= mmac
->next
;
2590 mmac_p
= &mmac
->next
;
2593 free_tlist(origline
);
2594 free_tlist(spec
.dlist
);
2595 return DIRECTIVE_FOUND
;
2599 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
2600 tline
= tline
->next
;
2601 if (tline
->next
== NULL
) {
2602 free_tlist(origline
);
2603 error(ERR_NONFATAL
, "`%%rotate' missing rotate count");
2604 return DIRECTIVE_FOUND
;
2606 t
= expand_smacro(tline
->next
);
2608 free_tlist(origline
);
2611 tokval
.t_type
= TOKEN_INVALID
;
2613 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2616 return DIRECTIVE_FOUND
;
2618 error(ERR_WARNING
|ERR_PASS1
,
2619 "trailing garbage after expression ignored");
2620 if (!is_simple(evalresult
)) {
2621 error(ERR_NONFATAL
, "non-constant value given to `%%rotate'");
2622 return DIRECTIVE_FOUND
;
2625 while (mmac
&& !mmac
->name
) /* avoid mistaking %reps for macros */
2626 mmac
= mmac
->next_active
;
2628 error(ERR_NONFATAL
, "`%%rotate' invoked outside a macro call");
2629 } else if (mmac
->nparam
== 0) {
2631 "`%%rotate' invoked within macro without parameters");
2633 int rotate
= mmac
->rotate
+ reloc_value(evalresult
);
2635 rotate
%= (int)mmac
->nparam
;
2637 rotate
+= mmac
->nparam
;
2639 mmac
->rotate
= rotate
;
2641 return DIRECTIVE_FOUND
;
2646 tline
= tline
->next
;
2647 } while (tok_type_(tline
, TOK_WHITESPACE
));
2649 if (tok_type_(tline
, TOK_ID
) &&
2650 nasm_stricmp(tline
->text
, ".nolist") == 0) {
2653 tline
= tline
->next
;
2654 } while (tok_type_(tline
, TOK_WHITESPACE
));
2658 t
= expand_smacro(tline
);
2660 tokval
.t_type
= TOKEN_INVALID
;
2662 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2664 free_tlist(origline
);
2665 return DIRECTIVE_FOUND
;
2668 error(ERR_WARNING
|ERR_PASS1
,
2669 "trailing garbage after expression ignored");
2670 if (!is_simple(evalresult
)) {
2671 error(ERR_NONFATAL
, "non-constant value given to `%%rep'");
2672 return DIRECTIVE_FOUND
;
2674 count
= reloc_value(evalresult
) + 1;
2676 error(ERR_NONFATAL
, "`%%rep' expects a repeat count");
2679 free_tlist(origline
);
2681 tmp_defining
= defining
;
2682 defining
= nasm_malloc(sizeof(MMacro
));
2683 defining
->name
= NULL
; /* flags this macro as a %rep block */
2684 defining
->casesense
= false;
2685 defining
->plus
= false;
2686 defining
->nolist
= nolist
;
2687 defining
->in_progress
= count
;
2688 defining
->nparam_min
= defining
->nparam_max
= 0;
2689 defining
->defaults
= NULL
;
2690 defining
->dlist
= NULL
;
2691 defining
->expansion
= NULL
;
2692 defining
->next_active
= istk
->mstk
;
2693 defining
->rep_nest
= tmp_defining
;
2694 return DIRECTIVE_FOUND
;
2697 if (!defining
|| defining
->name
) {
2698 error(ERR_NONFATAL
, "`%%endrep': no matching `%%rep'");
2699 return DIRECTIVE_FOUND
;
2703 * Now we have a "macro" defined - although it has no name
2704 * and we won't be entering it in the hash tables - we must
2705 * push a macro-end marker for it on to istk->expansion.
2706 * After that, it will take care of propagating itself (a
2707 * macro-end marker line for a macro which is really a %rep
2708 * block will cause the macro to be re-expanded, complete
2709 * with another macro-end marker to ensure the process
2710 * continues) until the whole expansion is forcibly removed
2711 * from istk->expansion by a %exitrep.
2713 l
= nasm_malloc(sizeof(Line
));
2714 l
->next
= istk
->expansion
;
2715 l
->finishes
= defining
;
2717 istk
->expansion
= l
;
2719 istk
->mstk
= defining
;
2721 list
->uplevel(defining
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
2722 tmp_defining
= defining
;
2723 defining
= defining
->rep_nest
;
2724 free_tlist(origline
);
2725 return DIRECTIVE_FOUND
;
2729 * We must search along istk->expansion until we hit a
2730 * macro-end marker for a macro with no name. Then we set
2731 * its `in_progress' flag to 0.
2733 for (l
= istk
->expansion
; l
; l
= l
->next
)
2734 if (l
->finishes
&& !l
->finishes
->name
)
2738 l
->finishes
->in_progress
= 1;
2740 error(ERR_NONFATAL
, "`%%exitrep' not within `%%rep' block");
2741 free_tlist(origline
);
2742 return DIRECTIVE_FOUND
;
2748 casesense
= (i
== PP_DEFINE
|| i
== PP_XDEFINE
);
2750 tline
= tline
->next
;
2752 tline
= expand_id(tline
);
2753 if (!tline
|| (tline
->type
!= TOK_ID
&&
2754 (tline
->type
!= TOK_PREPROC_ID
||
2755 tline
->text
[1] != '$'))) {
2756 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
2758 free_tlist(origline
);
2759 return DIRECTIVE_FOUND
;
2762 ctx
= get_ctx(tline
->text
, false);
2764 mname
= tline
->text
;
2766 param_start
= tline
= tline
->next
;
2769 /* Expand the macro definition now for %xdefine and %ixdefine */
2770 if ((i
== PP_XDEFINE
) || (i
== PP_IXDEFINE
))
2771 tline
= expand_smacro(tline
);
2773 if (tok_is_(tline
, "(")) {
2775 * This macro has parameters.
2778 tline
= tline
->next
;
2782 error(ERR_NONFATAL
, "parameter identifier expected");
2783 free_tlist(origline
);
2784 return DIRECTIVE_FOUND
;
2786 if (tline
->type
!= TOK_ID
) {
2788 "`%s': parameter identifier expected",
2790 free_tlist(origline
);
2791 return DIRECTIVE_FOUND
;
2793 tline
->type
= TOK_SMAC_PARAM
+ nparam
++;
2794 tline
= tline
->next
;
2796 if (tok_is_(tline
, ",")) {
2797 tline
= tline
->next
;
2799 if (!tok_is_(tline
, ")")) {
2801 "`)' expected to terminate macro template");
2802 free_tlist(origline
);
2803 return DIRECTIVE_FOUND
;
2809 tline
= tline
->next
;
2811 if (tok_type_(tline
, TOK_WHITESPACE
))
2812 last
= tline
, tline
= tline
->next
;
2817 if (t
->type
== TOK_ID
) {
2818 for (tt
= param_start
; tt
; tt
= tt
->next
)
2819 if (tt
->type
>= TOK_SMAC_PARAM
&&
2820 !strcmp(tt
->text
, t
->text
))
2824 t
->next
= macro_start
;
2829 * Good. We now have a macro name, a parameter count, and a
2830 * token list (in reverse order) for an expansion. We ought
2831 * to be OK just to create an SMacro, store it, and let
2832 * free_tlist have the rest of the line (which we have
2833 * carefully re-terminated after chopping off the expansion
2836 define_smacro(ctx
, mname
, casesense
, nparam
, macro_start
);
2837 free_tlist(origline
);
2838 return DIRECTIVE_FOUND
;
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] != '$'))) {
2847 error(ERR_NONFATAL
, "`%%undef' expects a macro identifier");
2848 free_tlist(origline
);
2849 return DIRECTIVE_FOUND
;
2852 error(ERR_WARNING
|ERR_PASS1
,
2853 "trailing garbage after macro name ignored");
2856 /* Find the context that symbol belongs to */
2857 ctx
= get_ctx(tline
->text
, false);
2858 undef_smacro(ctx
, tline
->text
);
2859 free_tlist(origline
);
2860 return DIRECTIVE_FOUND
;
2864 casesense
= (i
== PP_DEFSTR
);
2866 tline
= tline
->next
;
2868 tline
= expand_id(tline
);
2869 if (!tline
|| (tline
->type
!= TOK_ID
&&
2870 (tline
->type
!= TOK_PREPROC_ID
||
2871 tline
->text
[1] != '$'))) {
2872 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
2874 free_tlist(origline
);
2875 return DIRECTIVE_FOUND
;
2878 ctx
= get_ctx(tline
->text
, false);
2880 mname
= tline
->text
;
2882 tline
= expand_smacro(tline
->next
);
2885 while (tok_type_(tline
, TOK_WHITESPACE
))
2886 tline
= delete_Token(tline
);
2888 p
= detoken(tline
, false);
2889 macro_start
= nasm_malloc(sizeof(*macro_start
));
2890 macro_start
->next
= NULL
;
2891 macro_start
->text
= nasm_quote(p
, strlen(p
));
2892 macro_start
->type
= TOK_STRING
;
2893 macro_start
->a
.mac
= NULL
;
2897 * We now have a macro name, an implicit parameter count of
2898 * zero, and a string token to use as an expansion. Create
2899 * and store an SMacro.
2901 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2902 free_tlist(origline
);
2903 return DIRECTIVE_FOUND
;
2908 StrList
*xsl
= NULL
;
2909 StrList
**xst
= &xsl
;
2913 tline
= tline
->next
;
2915 tline
= expand_id(tline
);
2916 if (!tline
|| (tline
->type
!= TOK_ID
&&
2917 (tline
->type
!= TOK_PREPROC_ID
||
2918 tline
->text
[1] != '$'))) {
2920 "`%%pathsearch' expects a macro identifier as first parameter");
2921 free_tlist(origline
);
2922 return DIRECTIVE_FOUND
;
2924 ctx
= get_ctx(tline
->text
, false);
2926 mname
= tline
->text
;
2928 tline
= expand_smacro(tline
->next
);
2932 while (tok_type_(t
, TOK_WHITESPACE
))
2935 if (!t
|| (t
->type
!= TOK_STRING
&&
2936 t
->type
!= TOK_INTERNAL_STRING
)) {
2937 error(ERR_NONFATAL
, "`%%pathsearch' expects a file name");
2939 free_tlist(origline
);
2940 return DIRECTIVE_FOUND
; /* but we did _something_ */
2943 error(ERR_WARNING
|ERR_PASS1
,
2944 "trailing garbage after `%%pathsearch' ignored");
2946 if (t
->type
!= TOK_INTERNAL_STRING
)
2947 nasm_unquote(p
, NULL
);
2949 fp
= inc_fopen(p
, &xsl
, &xst
, true);
2952 fclose(fp
); /* Don't actually care about the file */
2954 macro_start
= nasm_malloc(sizeof(*macro_start
));
2955 macro_start
->next
= NULL
;
2956 macro_start
->text
= nasm_quote(p
, strlen(p
));
2957 macro_start
->type
= TOK_STRING
;
2958 macro_start
->a
.mac
= NULL
;
2963 * We now have a macro name, an implicit parameter count of
2964 * zero, and a string token to use as an expansion. Create
2965 * and store an SMacro.
2967 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2969 free_tlist(origline
);
2970 return DIRECTIVE_FOUND
;
2976 tline
= tline
->next
;
2978 tline
= expand_id(tline
);
2979 if (!tline
|| (tline
->type
!= TOK_ID
&&
2980 (tline
->type
!= TOK_PREPROC_ID
||
2981 tline
->text
[1] != '$'))) {
2983 "`%%strlen' expects a macro identifier as first parameter");
2984 free_tlist(origline
);
2985 return DIRECTIVE_FOUND
;
2987 ctx
= get_ctx(tline
->text
, false);
2989 mname
= tline
->text
;
2991 tline
= expand_smacro(tline
->next
);
2995 while (tok_type_(t
, TOK_WHITESPACE
))
2997 /* t should now point to the string */
2998 if (t
->type
!= TOK_STRING
) {
3000 "`%%strlen` requires string as second parameter");
3002 free_tlist(origline
);
3003 return DIRECTIVE_FOUND
;
3006 macro_start
= nasm_malloc(sizeof(*macro_start
));
3007 macro_start
->next
= NULL
;
3008 make_tok_num(macro_start
, nasm_unquote(t
->text
, NULL
));
3009 macro_start
->a
.mac
= NULL
;
3012 * We now have a macro name, an implicit parameter count of
3013 * zero, and a numeric token to use as an expansion. Create
3014 * and store an SMacro.
3016 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3018 free_tlist(origline
);
3019 return DIRECTIVE_FOUND
;
3024 tline
= tline
->next
;
3026 tline
= expand_id(tline
);
3027 if (!tline
|| (tline
->type
!= TOK_ID
&&
3028 (tline
->type
!= TOK_PREPROC_ID
||
3029 tline
->text
[1] != '$'))) {
3031 "`%%strcat' expects a macro identifier as first parameter");
3032 free_tlist(origline
);
3033 return DIRECTIVE_FOUND
;
3035 ctx
= get_ctx(tline
->text
, false);
3037 mname
= tline
->text
;
3039 tline
= expand_smacro(tline
->next
);
3043 for (t
= tline
; t
; t
= t
->next
) {
3045 case TOK_WHITESPACE
:
3048 len
+= t
->a
.len
= nasm_unquote(t
->text
, NULL
);
3051 if (!strcmp(t
->text
, ",")) /* permit comma separators */
3053 /* else fall through */
3056 "non-string passed to `%%strcat' (%d)", t
->type
);
3058 free_tlist(origline
);
3059 return DIRECTIVE_FOUND
;
3063 p
= pp
= nasm_malloc(len
);
3065 for (t
= tline
; t
; t
= t
->next
) {
3066 if (t
->type
== TOK_STRING
) {
3067 memcpy(p
, t
->text
, t
->a
.len
);
3073 * We now have a macro name, an implicit parameter count of
3074 * zero, and a numeric token to use as an expansion. Create
3075 * and store an SMacro.
3077 macro_start
= new_Token(NULL
, TOK_STRING
, NULL
, 0);
3078 macro_start
->text
= nasm_quote(pp
, len
);
3080 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3082 free_tlist(origline
);
3083 return DIRECTIVE_FOUND
;
3092 tline
= tline
->next
;
3094 tline
= expand_id(tline
);
3095 if (!tline
|| (tline
->type
!= TOK_ID
&&
3096 (tline
->type
!= TOK_PREPROC_ID
||
3097 tline
->text
[1] != '$'))) {
3099 "`%%substr' expects a macro identifier as first parameter");
3100 free_tlist(origline
);
3101 return DIRECTIVE_FOUND
;
3103 ctx
= get_ctx(tline
->text
, false);
3105 mname
= tline
->text
;
3107 tline
= expand_smacro(tline
->next
);
3111 while (tok_type_(t
, TOK_WHITESPACE
))
3114 /* t should now point to the string */
3115 if (t
->type
!= TOK_STRING
) {
3117 "`%%substr` requires string as second parameter");
3119 free_tlist(origline
);
3120 return DIRECTIVE_FOUND
;
3125 tokval
.t_type
= TOKEN_INVALID
;
3126 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3130 free_tlist(origline
);
3131 return DIRECTIVE_FOUND
;
3132 } else if (!is_simple(evalresult
)) {
3133 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3135 free_tlist(origline
);
3136 return DIRECTIVE_FOUND
;
3138 a1
= evalresult
->value
-1;
3140 while (tok_type_(tt
, TOK_WHITESPACE
))
3143 a2
= 1; /* Backwards compatibility: one character */
3145 tokval
.t_type
= TOKEN_INVALID
;
3146 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3150 free_tlist(origline
);
3151 return DIRECTIVE_FOUND
;
3152 } else if (!is_simple(evalresult
)) {
3153 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3155 free_tlist(origline
);
3156 return DIRECTIVE_FOUND
;
3158 a2
= evalresult
->value
;
3161 len
= nasm_unquote(t
->text
, NULL
);
3164 if (a1
+a2
> (int64_t)len
)
3167 macro_start
= nasm_malloc(sizeof(*macro_start
));
3168 macro_start
->next
= NULL
;
3169 macro_start
->text
= nasm_quote((a1
< 0) ? "" : t
->text
+a1
, a2
);
3170 macro_start
->type
= TOK_STRING
;
3171 macro_start
->a
.mac
= NULL
;
3174 * We now have a macro name, an implicit parameter count of
3175 * zero, and a numeric token to use as an expansion. Create
3176 * and store an SMacro.
3178 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3180 free_tlist(origline
);
3181 return DIRECTIVE_FOUND
;
3186 casesense
= (i
== PP_ASSIGN
);
3188 tline
= tline
->next
;
3190 tline
= expand_id(tline
);
3191 if (!tline
|| (tline
->type
!= TOK_ID
&&
3192 (tline
->type
!= TOK_PREPROC_ID
||
3193 tline
->text
[1] != '$'))) {
3195 "`%%%sassign' expects a macro identifier",
3196 (i
== PP_IASSIGN
? "i" : ""));
3197 free_tlist(origline
);
3198 return DIRECTIVE_FOUND
;
3200 ctx
= get_ctx(tline
->text
, false);
3202 mname
= tline
->text
;
3204 tline
= expand_smacro(tline
->next
);
3209 tokval
.t_type
= TOKEN_INVALID
;
3211 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3214 free_tlist(origline
);
3215 return DIRECTIVE_FOUND
;
3219 error(ERR_WARNING
|ERR_PASS1
,
3220 "trailing garbage after expression ignored");
3222 if (!is_simple(evalresult
)) {
3224 "non-constant value given to `%%%sassign'",
3225 (i
== PP_IASSIGN
? "i" : ""));
3226 free_tlist(origline
);
3227 return DIRECTIVE_FOUND
;
3230 macro_start
= nasm_malloc(sizeof(*macro_start
));
3231 macro_start
->next
= NULL
;
3232 make_tok_num(macro_start
, reloc_value(evalresult
));
3233 macro_start
->a
.mac
= NULL
;
3236 * We now have a macro name, an implicit parameter count of
3237 * zero, and a numeric token to use as an expansion. Create
3238 * and store an SMacro.
3240 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3241 free_tlist(origline
);
3242 return DIRECTIVE_FOUND
;
3246 * Syntax is `%line nnn[+mmm] [filename]'
3248 tline
= tline
->next
;
3250 if (!tok_type_(tline
, TOK_NUMBER
)) {
3251 error(ERR_NONFATAL
, "`%%line' expects line number");
3252 free_tlist(origline
);
3253 return DIRECTIVE_FOUND
;
3255 k
= readnum(tline
->text
, &err
);
3257 tline
= tline
->next
;
3258 if (tok_is_(tline
, "+")) {
3259 tline
= tline
->next
;
3260 if (!tok_type_(tline
, TOK_NUMBER
)) {
3261 error(ERR_NONFATAL
, "`%%line' expects line increment");
3262 free_tlist(origline
);
3263 return DIRECTIVE_FOUND
;
3265 m
= readnum(tline
->text
, &err
);
3266 tline
= tline
->next
;
3272 nasm_free(src_set_fname(detoken(tline
, false)));
3274 free_tlist(origline
);
3275 return DIRECTIVE_FOUND
;
3279 "preprocessor directive `%s' not yet implemented",
3281 return DIRECTIVE_FOUND
;
3286 * Ensure that a macro parameter contains a condition code and
3287 * nothing else. Return the condition code index if so, or -1
3290 static int find_cc(Token
* t
)
3296 return -1; /* Probably a %+ without a space */
3299 if (t
->type
!= TOK_ID
)
3303 if (tt
&& (tt
->type
!= TOK_OTHER
|| strcmp(tt
->text
, ",")))
3307 j
= elements(conditions
);
3310 m
= nasm_stricmp(t
->text
, conditions
[k
]);
3326 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3327 * %-n) and MMacro-local identifiers (%%foo).
3329 static Token
*expand_mmac_params(Token
* tline
)
3331 Token
*t
, *tt
, **tail
, *thead
;
3337 if (tline
->type
== TOK_PREPROC_ID
&&
3338 (((tline
->text
[1] == '+' || tline
->text
[1] == '-')
3339 && tline
->text
[2]) || tline
->text
[1] == '%'
3340 || (tline
->text
[1] >= '0' && tline
->text
[1] <= '9'))) {
3342 int type
= 0, cc
; /* type = 0 to placate optimisers */
3349 tline
= tline
->next
;
3352 while (mac
&& !mac
->name
) /* avoid mistaking %reps for macros */
3353 mac
= mac
->next_active
;
3355 error(ERR_NONFATAL
, "`%s': not in a macro call", t
->text
);
3357 switch (t
->text
[1]) {
3359 * We have to make a substitution of one of the
3360 * forms %1, %-1, %+1, %%foo, %0.
3364 snprintf(tmpbuf
, sizeof(tmpbuf
), "%d", mac
->nparam
);
3365 text
= nasm_strdup(tmpbuf
);
3369 snprintf(tmpbuf
, sizeof(tmpbuf
), "..@%"PRIu64
".",
3371 text
= nasm_strcat(tmpbuf
, t
->text
+ 2);
3374 n
= atoi(t
->text
+ 2) - 1;
3375 if (n
>= mac
->nparam
)
3378 if (mac
->nparam
> 1)
3379 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3380 tt
= mac
->params
[n
];
3385 "macro parameter %d is not a condition code",
3390 if (inverse_ccs
[cc
] == -1) {
3392 "condition code `%s' is not invertible",
3397 nasm_strdup(conditions
[inverse_ccs
[cc
]]);
3401 n
= atoi(t
->text
+ 2) - 1;
3402 if (n
>= mac
->nparam
)
3405 if (mac
->nparam
> 1)
3406 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3407 tt
= mac
->params
[n
];
3412 "macro parameter %d is not a condition code",
3417 text
= nasm_strdup(conditions
[cc
]);
3421 n
= atoi(t
->text
+ 1) - 1;
3422 if (n
>= mac
->nparam
)
3425 if (mac
->nparam
> 1)
3426 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3427 tt
= mac
->params
[n
];
3430 for (i
= 0; i
< mac
->paramlen
[n
]; i
++) {
3431 *tail
= new_Token(NULL
, tt
->type
, tt
->text
, 0);
3432 tail
= &(*tail
)->next
;
3436 text
= NULL
; /* we've done it here */
3452 tline
= tline
->next
;
3459 for (; t
&& (tt
= t
->next
) != NULL
; t
= t
->next
)
3461 case TOK_WHITESPACE
:
3462 if (tt
->type
== TOK_WHITESPACE
) {
3463 t
->next
= delete_Token(tt
);
3468 if (tt
->type
== t
->type
|| tt
->type
== TOK_NUMBER
) {
3469 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3472 t
->next
= delete_Token(tt
);
3483 * Expand all single-line macro calls made in the given line.
3484 * Return the expanded version of the line. The original is deemed
3485 * to be destroyed in the process. (In reality we'll just move
3486 * Tokens from input to output a lot of the time, rather than
3487 * actually bothering to destroy and replicate.)
3489 #define DEADMAN_LIMIT (1 << 20)
3491 static Token
*expand_smacro(Token
* tline
)
3493 Token
*t
, *tt
, *mstart
, **tail
, *thead
;
3494 struct hash_table
*smtbl
;
3495 SMacro
*head
= NULL
, *m
;
3498 unsigned int nparam
, sparam
;
3499 int brackets
, rescan
;
3500 Token
*org_tline
= tline
;
3503 int deadman
= DEADMAN_LIMIT
;
3506 * Trick: we should avoid changing the start token pointer since it can
3507 * be contained in "next" field of other token. Because of this
3508 * we allocate a copy of first token and work with it; at the end of
3509 * routine we copy it back
3513 new_Token(org_tline
->next
, org_tline
->type
, org_tline
->text
,
3515 tline
->a
.mac
= org_tline
->a
.mac
;
3516 nasm_free(org_tline
->text
);
3517 org_tline
->text
= NULL
;
3524 while (tline
) { /* main token loop */
3526 error(ERR_NONFATAL
, "interminable macro recursion");
3530 if ((mname
= tline
->text
)) {
3531 /* if this token is a local macro, look in local context */
3534 if (tline
->type
== TOK_ID
|| tline
->type
== TOK_PREPROC_ID
) {
3535 ctx
= get_ctx(mname
, true);
3537 smtbl
= &ctx
->localmac
;
3539 head
= (SMacro
*) hash_findix(smtbl
, mname
);
3542 * We've hit an identifier. As in is_mmacro below, we first
3543 * check whether the identifier is a single-line macro at
3544 * all, then think about checking for parameters if
3547 for (m
= head
; m
; m
= m
->next
)
3548 if (!mstrcmp(m
->name
, mname
, m
->casesense
))
3554 if (m
->nparam
== 0) {
3556 * Simple case: the macro is parameterless. Discard the
3557 * one token that the macro call took, and push the
3558 * expansion back on the to-do stack.
3560 if (!m
->expansion
) {
3561 if (!strcmp("__FILE__", m
->name
)) {
3564 src_get(&num
, &file
);
3565 tline
->text
= nasm_quote(file
, strlen(file
));
3566 tline
->type
= TOK_STRING
;
3570 if (!strcmp("__LINE__", m
->name
)) {
3571 nasm_free(tline
->text
);
3572 make_tok_num(tline
, src_get_linnum());
3575 if (!strcmp("__BITS__", m
->name
)) {
3576 nasm_free(tline
->text
);
3577 make_tok_num(tline
, globalbits
);
3580 tline
= delete_Token(tline
);
3585 * Complicated case: at least one macro with this name
3586 * exists and takes parameters. We must find the
3587 * parameters in the call, count them, find the SMacro
3588 * that corresponds to that form of the macro call, and
3589 * substitute for the parameters when we expand. What a
3592 /*tline = tline->next;
3593 skip_white_(tline); */
3596 while (tok_type_(t
, TOK_SMAC_END
)) {
3597 t
->a
.mac
->in_progress
= false;
3599 t
= tline
->next
= delete_Token(t
);
3602 } while (tok_type_(tline
, TOK_WHITESPACE
));
3603 if (!tok_is_(tline
, "(")) {
3605 * This macro wasn't called with parameters: ignore
3606 * the call. (Behaviour borrowed from gnu cpp.)
3615 sparam
= PARAM_DELTA
;
3616 params
= nasm_malloc(sparam
* sizeof(Token
*));
3617 params
[0] = tline
->next
;
3618 paramsize
= nasm_malloc(sparam
* sizeof(int));
3620 while (true) { /* parameter loop */
3622 * For some unusual expansions
3623 * which concatenates function call
3626 while (tok_type_(t
, TOK_SMAC_END
)) {
3627 t
->a
.mac
->in_progress
= false;
3629 t
= tline
->next
= delete_Token(t
);
3635 "macro call expects terminating `)'");
3638 if (tline
->type
== TOK_WHITESPACE
3640 if (paramsize
[nparam
])
3643 params
[nparam
] = tline
->next
;
3644 continue; /* parameter loop */
3646 if (tline
->type
== TOK_OTHER
3647 && tline
->text
[1] == 0) {
3648 char ch
= tline
->text
[0];
3649 if (ch
== ',' && !paren
&& brackets
<= 0) {
3650 if (++nparam
>= sparam
) {
3651 sparam
+= PARAM_DELTA
;
3652 params
= nasm_realloc(params
,
3657 nasm_realloc(paramsize
,
3661 params
[nparam
] = tline
->next
;
3662 paramsize
[nparam
] = 0;
3664 continue; /* parameter loop */
3667 (brackets
> 0 || (brackets
== 0 &&
3668 !paramsize
[nparam
])))
3670 if (!(brackets
++)) {
3671 params
[nparam
] = tline
->next
;
3672 continue; /* parameter loop */
3675 if (ch
== '}' && brackets
> 0)
3676 if (--brackets
== 0) {
3678 continue; /* parameter loop */
3680 if (ch
== '(' && !brackets
)
3682 if (ch
== ')' && brackets
<= 0)
3688 error(ERR_NONFATAL
, "braces do not "
3689 "enclose all of macro parameter");
3691 paramsize
[nparam
] += white
+ 1;
3693 } /* parameter loop */
3695 while (m
&& (m
->nparam
!= nparam
||
3696 mstrcmp(m
->name
, mname
,
3700 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MNP
,
3701 "macro `%s' exists, "
3702 "but not taking %d parameters",
3703 mstart
->text
, nparam
);
3706 if (m
&& m
->in_progress
)
3708 if (!m
) { /* in progess or didn't find '(' or wrong nparam */
3710 * Design question: should we handle !tline, which
3711 * indicates missing ')' here, or expand those
3712 * macros anyway, which requires the (t) test a few
3716 nasm_free(paramsize
);
3720 * Expand the macro: we are placed on the last token of the
3721 * call, so that we can easily split the call from the
3722 * following tokens. We also start by pushing an SMAC_END
3723 * token for the cycle removal.
3730 tt
= new_Token(tline
, TOK_SMAC_END
, NULL
, 0);
3732 m
->in_progress
= true;
3734 for (t
= m
->expansion
; t
; t
= t
->next
) {
3735 if (t
->type
>= TOK_SMAC_PARAM
) {
3736 Token
*pcopy
= tline
, **ptail
= &pcopy
;
3740 ttt
= params
[t
->type
- TOK_SMAC_PARAM
];
3741 for (i
= paramsize
[t
->type
- TOK_SMAC_PARAM
];
3744 new_Token(tline
, ttt
->type
, ttt
->text
,
3750 } else if (t
->type
== TOK_PREPROC_Q
) {
3751 tt
= new_Token(tline
, TOK_ID
, mname
, 0);
3753 } else if (t
->type
== TOK_PREPROC_QQ
) {
3754 tt
= new_Token(tline
, TOK_ID
, m
->name
, 0);
3757 tt
= new_Token(tline
, t
->type
, t
->text
, 0);
3763 * Having done that, get rid of the macro call, and clean
3764 * up the parameters.
3767 nasm_free(paramsize
);
3769 continue; /* main token loop */
3774 if (tline
->type
== TOK_SMAC_END
) {
3775 tline
->a
.mac
->in_progress
= false;
3776 tline
= delete_Token(tline
);
3779 tline
= tline
->next
;
3787 * Now scan the entire line and look for successive TOK_IDs that resulted
3788 * after expansion (they can't be produced by tokenize()). The successive
3789 * TOK_IDs should be concatenated.
3790 * Also we look for %+ tokens and concatenate the tokens before and after
3791 * them (without white spaces in between).
3796 while (t
&& t
->type
!= TOK_ID
&& t
->type
!= TOK_PREPROC_ID
)
3800 if (t
->next
->type
== TOK_ID
||
3801 t
->next
->type
== TOK_PREPROC_ID
||
3802 t
->next
->type
== TOK_NUMBER
) {
3803 char *p
= nasm_strcat(t
->text
, t
->next
->text
);
3805 t
->next
= delete_Token(t
->next
);
3808 } else if (t
->next
->type
== TOK_WHITESPACE
&& t
->next
->next
&&
3809 t
->next
->next
->type
== TOK_PREPROC_ID
&&
3810 strcmp(t
->next
->next
->text
, "%+") == 0) {
3811 /* free the next whitespace, the %+ token and next whitespace */
3813 for (i
= 1; i
<= 3; i
++) {
3815 || (i
!= 2 && t
->next
->type
!= TOK_WHITESPACE
))
3817 t
->next
= delete_Token(t
->next
);
3822 /* If we concatenaded something, re-scan the line for macros */
3830 *org_tline
= *thead
;
3831 /* since we just gave text to org_line, don't free it */
3833 delete_Token(thead
);
3835 /* the expression expanded to empty line;
3836 we can't return NULL for some reasons
3837 we just set the line to a single WHITESPACE token. */
3838 memset(org_tline
, 0, sizeof(*org_tline
));
3839 org_tline
->text
= NULL
;
3840 org_tline
->type
= TOK_WHITESPACE
;
3849 * Similar to expand_smacro but used exclusively with macro identifiers
3850 * right before they are fetched in. The reason is that there can be
3851 * identifiers consisting of several subparts. We consider that if there
3852 * are more than one element forming the name, user wants a expansion,
3853 * otherwise it will be left as-is. Example:
3857 * the identifier %$abc will be left as-is so that the handler for %define
3858 * will suck it and define the corresponding value. Other case:
3860 * %define _%$abc cde
3862 * In this case user wants name to be expanded *before* %define starts
3863 * working, so we'll expand %$abc into something (if it has a value;
3864 * otherwise it will be left as-is) then concatenate all successive
3867 static Token
*expand_id(Token
* tline
)
3869 Token
*cur
, *oldnext
= NULL
;
3871 if (!tline
|| !tline
->next
)
3876 (cur
->next
->type
== TOK_ID
||
3877 cur
->next
->type
== TOK_PREPROC_ID
3878 || cur
->next
->type
== TOK_NUMBER
))
3881 /* If identifier consists of just one token, don't expand */
3886 oldnext
= cur
->next
; /* Detach the tail past identifier */
3887 cur
->next
= NULL
; /* so that expand_smacro stops here */
3890 tline
= expand_smacro(tline
);
3893 /* expand_smacro possibly changhed tline; re-scan for EOL */
3895 while (cur
&& cur
->next
)
3898 cur
->next
= oldnext
;
3905 * Expand indirect tokens, %[...]. Just like expand_smacro(),
3906 * the input is considered destroyed.
3908 * XXX: fix duplicated code in this function and in expand_mmac_params()
3910 static Token
*expand_indirect(Token
* tline
, int level
)
3912 const int max_indirect_level
= 1000;
3913 Token
*t
, *thead
, **tp
;
3917 if (level
>= max_indirect_level
) {
3918 error(ERR_NONFATAL
, "interminable indirect expansion");
3923 if (t
->type
!= TOK_INDIRECT
) {
3927 it
= tokenize(t
->text
);
3928 it
= expand_indirect(it
, level
+1);
3929 it
= expand_smacro(it
);
3932 switch (thead
? thead
->type
: TOK_NONE
) {
3933 case TOK_WHITESPACE
:
3934 skip
= (it
->type
== TOK_WHITESPACE
);
3938 if (it
->type
== thead
->type
|| it
->type
== TOK_NUMBER
) {
3939 char *tmp
= nasm_strcat(thead
->text
, it
->text
);
3940 nasm_free(thead
->text
);
3949 it
= delete_Token(it
);
3960 switch (thead
? thead
->type
: TOK_NONE
) {
3961 case TOK_WHITESPACE
:
3962 skip
= (it
->type
== TOK_WHITESPACE
);
3966 if (it
->type
== thead
->type
|| it
->type
== TOK_NUMBER
) {
3967 char *tmp
= nasm_strcat(thead
->text
, it
->text
);
3968 nasm_free(thead
->text
);
3978 *tp
= thead
= it
->next
;
3979 t
= delete_Token(t
);
3983 t
= delete_Token(t
);
3991 * Determine whether the given line constitutes a multi-line macro
3992 * call, and return the MMacro structure called if so. Doesn't have
3993 * to check for an initial label - that's taken care of in
3994 * expand_mmacro - but must check numbers of parameters. Guaranteed
3995 * to be called with tline->type == TOK_ID, so the putative macro
3996 * name is easy to find.
3998 static MMacro
*is_mmacro(Token
* tline
, Token
*** params_array
)
4004 head
= (MMacro
*) hash_findix(&mmacros
, tline
->text
);
4007 * Efficiency: first we see if any macro exists with the given
4008 * name. If not, we can return NULL immediately. _Then_ we
4009 * count the parameters, and then we look further along the
4010 * list if necessary to find the proper MMacro.
4012 for (m
= head
; m
; m
= m
->next
)
4013 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
4019 * OK, we have a potential macro. Count and demarcate the
4022 count_mmac_params(tline
->next
, &nparam
, ¶ms
);
4025 * So we know how many parameters we've got. Find the MMacro
4026 * structure that handles this number.
4029 if (m
->nparam_min
<= nparam
4030 && (m
->plus
|| nparam
<= m
->nparam_max
)) {
4032 * This one is right. Just check if cycle removal
4033 * prohibits us using it before we actually celebrate...
4035 if (m
->in_progress
) {
4038 "self-reference in multi-line macro `%s'", m
->name
);
4044 * It's right, and we can use it. Add its default
4045 * parameters to the end of our list if necessary.
4047 if (m
->defaults
&& nparam
< m
->nparam_min
+ m
->ndefs
) {
4049 nasm_realloc(params
,
4050 ((m
->nparam_min
+ m
->ndefs
+
4051 1) * sizeof(*params
)));
4052 while (nparam
< m
->nparam_min
+ m
->ndefs
) {
4053 params
[nparam
] = m
->defaults
[nparam
- m
->nparam_min
];
4058 * If we've gone over the maximum parameter count (and
4059 * we're in Plus mode), ignore parameters beyond
4062 if (m
->plus
&& nparam
> m
->nparam_max
)
4063 nparam
= m
->nparam_max
;
4065 * Then terminate the parameter list, and leave.
4067 if (!params
) { /* need this special case */
4068 params
= nasm_malloc(sizeof(*params
));
4071 params
[nparam
] = NULL
;
4072 *params_array
= params
;
4076 * This one wasn't right: look for the next one with the
4079 for (m
= m
->next
; m
; m
= m
->next
)
4080 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
4085 * After all that, we didn't find one with the right number of
4086 * parameters. Issue a warning, and fail to expand the macro.
4088 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MNP
,
4089 "macro `%s' exists, but not taking %d parameters",
4090 tline
->text
, nparam
);
4096 * Expand the multi-line macro call made by the given line, if
4097 * there is one to be expanded. If there is, push the expansion on
4098 * istk->expansion and return 1. Otherwise return 0.
4100 static int expand_mmacro(Token
* tline
)
4102 Token
*startline
= tline
;
4103 Token
*label
= NULL
;
4104 int dont_prepend
= 0;
4105 Token
**params
, *t
, *mtok
, *tt
;
4108 int i
, nparam
, *paramlen
;
4113 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
4114 if (!tok_type_(t
, TOK_ID
) && !tok_type_(t
, TOK_PREPROC_ID
))
4117 m
= is_mmacro(t
, ¶ms
);
4123 * We have an id which isn't a macro call. We'll assume
4124 * it might be a label; we'll also check to see if a
4125 * colon follows it. Then, if there's another id after
4126 * that lot, we'll check it again for macro-hood.
4130 if (tok_type_(t
, TOK_WHITESPACE
))
4131 last
= t
, t
= t
->next
;
4132 if (tok_is_(t
, ":")) {
4134 last
= t
, t
= t
->next
;
4135 if (tok_type_(t
, TOK_WHITESPACE
))
4136 last
= t
, t
= t
->next
;
4138 if (!tok_type_(t
, TOK_ID
) || (m
= is_mmacro(t
, ¶ms
)) == NULL
)
4146 * Fix up the parameters: this involves stripping leading and
4147 * trailing whitespace, then stripping braces if they are
4150 for (nparam
= 0; params
[nparam
]; nparam
++) ;
4151 paramlen
= nparam
? nasm_malloc(nparam
* sizeof(*paramlen
)) : NULL
;
4153 for (i
= 0; params
[i
]; i
++) {
4155 int comma
= (!m
->plus
|| i
< nparam
- 1);
4159 if (tok_is_(t
, "{"))
4160 t
= t
->next
, brace
= true, comma
= false;
4164 if (comma
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, ","))
4165 break; /* ... because we have hit a comma */
4166 if (comma
&& t
->type
== TOK_WHITESPACE
4167 && tok_is_(t
->next
, ","))
4168 break; /* ... or a space then a comma */
4169 if (brace
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, "}"))
4170 break; /* ... or a brace */
4177 * OK, we have a MMacro structure together with a set of
4178 * parameters. We must now go through the expansion and push
4179 * copies of each Line on to istk->expansion. Substitution of
4180 * parameter tokens and macro-local tokens doesn't get done
4181 * until the single-line macro substitution process; this is
4182 * because delaying them allows us to change the semantics
4183 * later through %rotate.
4185 * First, push an end marker on to istk->expansion, mark this
4186 * macro as in progress, and set up its invocation-specific
4189 ll
= nasm_malloc(sizeof(Line
));
4190 ll
->next
= istk
->expansion
;
4193 istk
->expansion
= ll
;
4195 m
->in_progress
= true;
4200 m
->paramlen
= paramlen
;
4201 m
->unique
= unique
++;
4204 m
->next_active
= istk
->mstk
;
4207 for (l
= m
->expansion
; l
; l
= l
->next
) {
4210 ll
= nasm_malloc(sizeof(Line
));
4211 ll
->finishes
= NULL
;
4212 ll
->next
= istk
->expansion
;
4213 istk
->expansion
= ll
;
4216 for (t
= l
->first
; t
; t
= t
->next
) {
4220 tt
= *tail
= new_Token(NULL
, TOK_ID
, mname
, 0);
4222 case TOK_PREPROC_QQ
:
4223 tt
= *tail
= new_Token(NULL
, TOK_ID
, m
->name
, 0);
4225 case TOK_PREPROC_ID
:
4226 if (t
->text
[1] == '0' && t
->text
[2] == '0') {
4234 tt
= *tail
= new_Token(NULL
, x
->type
, x
->text
, 0);
4243 * If we had a label, push it on as the first line of
4244 * the macro expansion.
4247 if (dont_prepend
< 0)
4248 free_tlist(startline
);
4250 ll
= nasm_malloc(sizeof(Line
));
4251 ll
->finishes
= NULL
;
4252 ll
->next
= istk
->expansion
;
4253 istk
->expansion
= ll
;
4254 ll
->first
= startline
;
4255 if (!dont_prepend
) {
4257 label
= label
->next
;
4258 label
->next
= tt
= new_Token(NULL
, TOK_OTHER
, ":", 0);
4263 list
->uplevel(m
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
4268 /* The function that actually does the error reporting */
4269 static void verror(int severity
, const char *fmt
, va_list arg
)
4273 vsnprintf(buff
, sizeof(buff
), fmt
, arg
);
4275 if (istk
&& istk
->mstk
&& istk
->mstk
->name
)
4276 _error(severity
, "(%s:%d) %s", istk
->mstk
->name
,
4277 istk
->mstk
->lineno
, buff
);
4279 _error(severity
, "%s", buff
);
4283 * Since preprocessor always operate only on the line that didn't
4284 * arrived yet, we should always use ERR_OFFBY1.
4286 static void error(int severity
, const char *fmt
, ...)
4290 /* If we're in a dead branch of IF or something like it, ignore the error */
4291 if (istk
&& istk
->conds
&& !emitting(istk
->conds
->state
))
4295 verror(severity
, fmt
, arg
);
4300 * Because %else etc are evaluated in the state context
4301 * of the previous branch, errors might get lost with error():
4302 * %if 0 ... %else trailing garbage ... %endif
4303 * So %else etc should report errors with this function.
4305 static void error_precond(int severity
, const char *fmt
, ...)
4309 /* Only ignore the error if it's really in a dead branch */
4310 if (istk
&& istk
->conds
&& istk
->conds
->state
== COND_NEVER
)
4314 verror(severity
, fmt
, arg
);
4319 pp_reset(char *file
, int apass
, efunc errfunc
, evalfunc eval
,
4320 ListGen
* listgen
, StrList
**deplist
)
4326 istk
= nasm_malloc(sizeof(Include
));
4329 istk
->expansion
= NULL
;
4331 istk
->fp
= fopen(file
, "r");
4333 src_set_fname(nasm_strdup(file
));
4337 error(ERR_FATAL
|ERR_NOFILE
, "unable to open input file `%s'",
4340 nested_mac_count
= 0;
4341 nested_rep_count
= 0;
4344 if (tasm_compatible_mode
) {
4345 stdmacpos
= nasm_stdmac
;
4347 stdmacpos
= nasm_stdmac_after_tasm
;
4349 any_extrastdmac
= extrastdmac
&& *extrastdmac
;
4355 * 0 for dependencies, 1 for preparatory passes, 2 for final pass.
4356 * The caller, however, will also pass in 3 for preprocess-only so
4357 * we can set __PASS__ accordingly.
4359 pass
= apass
> 2 ? 2 : apass
;
4361 dephead
= deptail
= deplist
;
4363 StrList
*sl
= nasm_malloc(strlen(file
)+1+sizeof sl
->next
);
4365 strcpy(sl
->str
, file
);
4367 deptail
= &sl
->next
;
4371 * Define the __PASS__ macro. This is defined here unlike
4372 * all the other builtins, because it is special -- it varies between
4375 t
= nasm_malloc(sizeof(*t
));
4377 make_tok_num(t
, apass
);
4379 define_smacro(NULL
, "__PASS__", true, 0, t
);
4382 static char *pp_getline(void)
4389 * Fetch a tokenized line, either from the macro-expansion
4390 * buffer or from the input file.
4393 while (istk
->expansion
&& istk
->expansion
->finishes
) {
4394 Line
*l
= istk
->expansion
;
4395 if (!l
->finishes
->name
&& l
->finishes
->in_progress
> 1) {
4399 * This is a macro-end marker for a macro with no
4400 * name, which means it's not really a macro at all
4401 * but a %rep block, and the `in_progress' field is
4402 * more than 1, meaning that we still need to
4403 * repeat. (1 means the natural last repetition; 0
4404 * means termination by %exitrep.) We have
4405 * therefore expanded up to the %endrep, and must
4406 * push the whole block on to the expansion buffer
4407 * again. We don't bother to remove the macro-end
4408 * marker: we'd only have to generate another one
4411 l
->finishes
->in_progress
--;
4412 for (l
= l
->finishes
->expansion
; l
; l
= l
->next
) {
4413 Token
*t
, *tt
, **tail
;
4415 ll
= nasm_malloc(sizeof(Line
));
4416 ll
->next
= istk
->expansion
;
4417 ll
->finishes
= NULL
;
4421 for (t
= l
->first
; t
; t
= t
->next
) {
4422 if (t
->text
|| t
->type
== TOK_WHITESPACE
) {
4424 new_Token(NULL
, t
->type
, t
->text
, 0);
4429 istk
->expansion
= ll
;
4433 * Check whether a `%rep' was started and not ended
4434 * within this macro expansion. This can happen and
4435 * should be detected. It's a fatal error because
4436 * I'm too confused to work out how to recover
4442 "defining with name in expansion");
4443 else if (istk
->mstk
->name
)
4445 "`%%rep' without `%%endrep' within"
4446 " expansion of macro `%s'",
4451 * FIXME: investigate the relationship at this point between
4452 * istk->mstk and l->finishes
4455 MMacro
*m
= istk
->mstk
;
4456 istk
->mstk
= m
->next_active
;
4459 * This was a real macro call, not a %rep, and
4460 * therefore the parameter information needs to
4463 nasm_free(m
->params
);
4464 free_tlist(m
->iline
);
4465 nasm_free(m
->paramlen
);
4466 l
->finishes
->in_progress
= false;
4470 istk
->expansion
= l
->next
;
4472 list
->downlevel(LIST_MACRO
);
4475 while (1) { /* until we get a line we can use */
4477 if (istk
->expansion
) { /* from a macro expansion */
4479 Line
*l
= istk
->expansion
;
4481 istk
->mstk
->lineno
++;
4483 istk
->expansion
= l
->next
;
4485 p
= detoken(tline
, false);
4486 list
->line(LIST_MACRO
, p
);
4491 if (line
) { /* from the current input file */
4492 line
= prepreproc(line
);
4493 tline
= tokenize(line
);
4498 * The current file has ended; work down the istk
4505 "expected `%%endif' before end of file");
4506 /* only set line and file name if there's a next node */
4508 src_set_linnum(i
->lineno
);
4509 nasm_free(src_set_fname(i
->fname
));
4512 list
->downlevel(LIST_INCLUDE
);
4516 if (istk
->expansion
&& istk
->expansion
->finishes
)
4522 * We must expand MMacro parameters and MMacro-local labels
4523 * _before_ we plunge into directive processing, to cope
4524 * with things like `%define something %1' such as STRUC
4525 * uses. Unless we're _defining_ a MMacro, in which case
4526 * those tokens should be left alone to go into the
4527 * definition; and unless we're in a non-emitting
4528 * condition, in which case we don't want to meddle with
4531 if (!defining
&& !(istk
->conds
&& !emitting(istk
->conds
->state
))
4532 && !(istk
->mstk
&& !istk
->mstk
->in_progress
)) {
4533 tline
= expand_indirect(tline
,0);
4534 tline
= expand_mmac_params(tline
);
4538 * Check the line to see if it's a preprocessor directive.
4540 if (do_directive(tline
) == DIRECTIVE_FOUND
) {
4542 } else if (defining
) {
4544 * We're defining a multi-line macro. We emit nothing
4546 * shove the tokenized line on to the macro definition.
4548 Line
*l
= nasm_malloc(sizeof(Line
));
4549 l
->next
= defining
->expansion
;
4552 defining
->expansion
= l
;
4554 } else if (istk
->conds
&& !emitting(istk
->conds
->state
)) {
4556 * We're in a non-emitting branch of a condition block.
4557 * Emit nothing at all, not even a blank line: when we
4558 * emerge from the condition we'll give a line-number
4559 * directive so we keep our place correctly.
4563 } else if (istk
->mstk
&& !istk
->mstk
->in_progress
) {
4565 * We're in a %rep block which has been terminated, so
4566 * we're walking through to the %endrep without
4567 * emitting anything. Emit nothing at all, not even a
4568 * blank line: when we emerge from the %rep block we'll
4569 * give a line-number directive so we keep our place
4575 tline
= expand_smacro(tline
);
4576 if (!expand_mmacro(tline
)) {
4578 * De-tokenize the line again, and emit it.
4580 line
= detoken(tline
, true);
4584 continue; /* expand_mmacro calls free_tlist */
4592 static void pp_cleanup(int pass
)
4595 if(defining
->name
) {
4597 "end of file while still defining macro `%s'",
4600 error(ERR_NONFATAL
, "end of file while still in %%rep");
4603 free_mmacro(defining
);
4612 nasm_free(i
->fname
);
4617 nasm_free(src_set_fname(NULL
));
4622 while ((i
= ipath
)) {
4631 void pp_include_path(char *path
)
4635 i
= nasm_malloc(sizeof(IncPath
));
4636 i
->path
= path
? nasm_strdup(path
) : NULL
;
4639 if (ipath
!= NULL
) {
4641 while (j
->next
!= NULL
)
4649 void pp_pre_include(char *fname
)
4651 Token
*inc
, *space
, *name
;
4654 name
= new_Token(NULL
, TOK_INTERNAL_STRING
, fname
, 0);
4655 space
= new_Token(name
, TOK_WHITESPACE
, NULL
, 0);
4656 inc
= new_Token(space
, TOK_PREPROC_ID
, "%include", 0);
4658 l
= nasm_malloc(sizeof(Line
));
4665 void pp_pre_define(char *definition
)
4671 equals
= strchr(definition
, '=');
4672 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4673 def
= new_Token(space
, TOK_PREPROC_ID
, "%define", 0);
4676 space
->next
= tokenize(definition
);
4680 l
= nasm_malloc(sizeof(Line
));
4687 void pp_pre_undefine(char *definition
)
4692 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4693 def
= new_Token(space
, TOK_PREPROC_ID
, "%undef", 0);
4694 space
->next
= tokenize(definition
);
4696 l
= nasm_malloc(sizeof(Line
));
4704 * Added by Keith Kanios:
4706 * This function is used to assist with "runtime" preprocessor
4707 * directives. (e.g. pp_runtime("%define __BITS__ 64");)
4709 * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
4710 * PASS A VALID STRING TO THIS FUNCTION!!!!!
4713 void pp_runtime(char *definition
)
4717 def
= tokenize(definition
);
4718 if(do_directive(def
) == NO_DIRECTIVE_FOUND
)
4723 void pp_extra_stdmac(macros_t
*macros
)
4725 extrastdmac
= macros
;
4728 static void make_tok_num(Token
* tok
, int64_t val
)
4731 snprintf(numbuf
, sizeof(numbuf
), "%"PRId64
"", val
);
4732 tok
->text
= nasm_strdup(numbuf
);
4733 tok
->type
= TOK_NUMBER
;