1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2012 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * preproc.c macro preprocessor for the Netwide Assembler
38 /* Typical flow of text through preproc
40 * pp_getline gets tokenized lines, either
42 * from a macro expansion
46 * read_line gets raw text from stdmacpos, or predef, or current input file
47 * tokenize converts to tokens
50 * expand_mmac_params is used to expand %1 etc., unless a macro is being
51 * defined or a false conditional is being processed
52 * (%0, %1, %+1, %-1, %%foo
54 * do_directive checks for directives
56 * expand_smacro is used to expand single line macros
58 * expand_mmacro is used to expand multi-line macros
60 * detoken is used to convert the line back to text
84 typedef struct SMacro SMacro
;
85 typedef struct MMacro MMacro
;
86 typedef struct MMacroInvocation MMacroInvocation
;
87 typedef struct Context Context
;
88 typedef struct Token Token
;
89 typedef struct Blocks Blocks
;
90 typedef struct Line Line
;
91 typedef struct Include Include
;
92 typedef struct Cond Cond
;
93 typedef struct IncPath IncPath
;
96 * Note on the storage of both SMacro and MMacros: the hash table
97 * indexes them case-insensitively, and we then have to go through a
98 * linked list of potential case aliases (and, for MMacros, parameter
99 * ranges); this is to preserve the matching semantics of the earlier
100 * code. If the number of case aliases for a specific macro is a
101 * performance issue, you may want to reconsider your coding style.
105 * Store the definition of a single-line macro.
117 * Store the definition of a multi-line macro. This is also used to
118 * store the interiors of `%rep...%endrep' blocks, which are
119 * effectively self-re-invoking multi-line macros which simply
120 * don't have a name or bother to appear in the hash tables. %rep
121 * blocks are signified by having a NULL `name' field.
123 * In a MMacro describing a `%rep' block, the `in_progress' field
124 * isn't merely boolean, but gives the number of repeats left to
127 * The `next' field is used for storing MMacros in hash tables; the
128 * `next_active' field is for stacking them on istk entries.
130 * When a MMacro is being expanded, `params', `iline', `nparam',
131 * `paramlen', `rotate' and `unique' are local to the invocation.
135 MMacroInvocation
*prev
; /* previous invocation */
137 int nparam_min
, nparam_max
;
139 bool plus
; /* is the last parameter greedy? */
140 bool nolist
; /* is this macro listing-inhibited? */
141 int64_t in_progress
; /* is this macro currently being expanded? */
142 int32_t max_depth
; /* maximum number of recursive expansions allowed */
143 Token
*dlist
; /* All defaults as one list */
144 Token
**defaults
; /* Parameter default pointers */
145 int ndefs
; /* number of default parameters */
149 MMacro
*rep_nest
; /* used for nesting %rep */
150 Token
**params
; /* actual parameters */
151 Token
*iline
; /* invocation line */
152 unsigned int nparam
, rotate
;
155 int lineno
; /* Current line number on expansion */
156 uint64_t condcnt
; /* number of if blocks... */
160 /* Store the definition of a multi-line macro, as defined in a
161 * previous recursive macro expansion.
163 struct MMacroInvocation
{
164 MMacroInvocation
*prev
; /* previous invocation */
165 Token
**params
; /* actual parameters */
166 Token
*iline
; /* invocation line */
167 unsigned int nparam
, rotate
;
175 * The context stack is composed of a linked list of these.
180 struct hash_table localmac
;
185 * This is the internal form which we break input lines up into.
186 * Typically stored in linked lists.
188 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
189 * necessarily used as-is, but is intended to denote the number of
190 * the substituted parameter. So in the definition
192 * %define a(x,y) ( (x) & ~(y) )
194 * the token representing `x' will have its type changed to
195 * TOK_SMAC_PARAM, but the one representing `y' will be
198 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
199 * which doesn't need quotes around it. Used in the pre-include
200 * mechanism as an alternative to trying to find a sensible type of
201 * quote to use on the filename we were passed.
204 TOK_NONE
= 0, TOK_WHITESPACE
, TOK_COMMENT
, TOK_ID
,
205 TOK_PREPROC_ID
, TOK_STRING
,
206 TOK_NUMBER
, TOK_FLOAT
, TOK_SMAC_END
, TOK_OTHER
,
208 TOK_PREPROC_Q
, TOK_PREPROC_QQ
,
210 TOK_INDIRECT
, /* %[...] */
211 TOK_SMAC_PARAM
, /* MUST BE LAST IN THE LIST!!! */
212 TOK_MAX
= INT_MAX
/* Keep compiler from reducing the range */
215 #define PP_CONCAT_MASK(x) (1 << (x))
216 #define PP_CONCAT_MATCH(t, mask) (PP_CONCAT_MASK((t)->type) & mask)
218 struct tokseq_match
{
227 SMacro
*mac
; /* associated macro for TOK_SMAC_END */
228 size_t len
; /* scratch length field */
229 } a
; /* Auxiliary data */
230 enum pp_token_type type
;
234 * Multi-line macro definitions are stored as a linked list of
235 * these, which is essentially a container to allow several linked
238 * Note that in this module, linked lists are treated as stacks
239 * wherever possible. For this reason, Lines are _pushed_ on to the
240 * `expansion' field in MMacro structures, so that the linked list,
241 * if walked, would give the macro lines in reverse order; this
242 * means that we can walk the list when expanding a macro, and thus
243 * push the lines on to the `expansion' field in _istk_ in reverse
244 * order (so that when popped back off they are in the right
245 * order). It may seem cockeyed, and it relies on my design having
246 * an even number of steps in, but it works...
248 * Some of these structures, rather than being actual lines, are
249 * markers delimiting the end of the expansion of a given macro.
250 * This is for use in the cycle-tracking and %rep-handling code.
251 * Such structures have `finishes' non-NULL, and `first' NULL. All
252 * others have `finishes' NULL, but `first' may still be NULL if
262 * To handle an arbitrary level of file inclusion, we maintain a
263 * stack (ie linked list) of these things.
272 MMacro
*mstk
; /* stack of active macros/reps */
276 * Include search path. This is simply a list of strings which get
277 * prepended, in turn, to the name of an include file, in an
278 * attempt to find the file if it's not in the current directory.
286 * Conditional assembly: we maintain a separate stack of these for
287 * each level of file inclusion. (The only reason we keep the
288 * stacks separate is to ensure that a stray `%endif' in a file
289 * included from within the true branch of a `%if' won't terminate
290 * it and cause confusion: instead, rightly, it'll cause an error.)
298 * These states are for use just after %if or %elif: IF_TRUE
299 * means the condition has evaluated to truth so we are
300 * currently emitting, whereas IF_FALSE means we are not
301 * currently emitting but will start doing so if a %else comes
302 * up. In these states, all directives are admissible: %elif,
303 * %else and %endif. (And of course %if.)
305 COND_IF_TRUE
, COND_IF_FALSE
,
307 * These states come up after a %else: ELSE_TRUE means we're
308 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
309 * any %elif or %else will cause an error.
311 COND_ELSE_TRUE
, COND_ELSE_FALSE
,
313 * These states mean that we're not emitting now, and also that
314 * nothing until %endif will be emitted at all. COND_DONE is
315 * used when we've had our moment of emission
316 * and have now started seeing %elifs. COND_NEVER is used when
317 * the condition construct in question is contained within a
318 * non-emitting branch of a larger condition construct,
319 * or if there is an error.
321 COND_DONE
, COND_NEVER
323 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
326 * These defines are used as the possible return values for do_directive
328 #define NO_DIRECTIVE_FOUND 0
329 #define DIRECTIVE_FOUND 1
332 * This define sets the upper limit for smacro and recursive mmacro
335 #define DEADMAN_LIMIT (1 << 20)
338 #define REP_LIMIT ((INT64_C(1) << 62))
341 * Condition codes. Note that we use c_ prefix not C_ because C_ is
342 * used in nasm.h for the "real" condition codes. At _this_ level,
343 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
344 * ones, so we need a different enum...
346 static const char * const conditions
[] = {
347 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
348 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
349 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
352 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_CXZ
, c_E
, c_ECXZ
, c_G
, c_GE
, c_L
, c_LE
,
353 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, c_NE
, c_NG
, c_NGE
, c_NL
, c_NLE
, c_NO
,
354 c_NP
, c_NS
, c_NZ
, c_O
, c_P
, c_PE
, c_PO
, c_RCXZ
, c_S
, c_Z
,
357 static const enum pp_conds inverse_ccs
[] = {
358 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, -1, c_NE
, -1, c_NG
, c_NGE
, c_NL
, c_NLE
,
359 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
,
360 c_Z
, c_NO
, c_NP
, c_PO
, c_PE
, -1, c_NS
, c_NZ
366 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
367 static int is_condition(enum preproc_token arg
)
369 return PP_IS_COND(arg
) || (arg
== PP_ELSE
) || (arg
== PP_ENDIF
);
372 /* For TASM compatibility we need to be able to recognise TASM compatible
373 * conditional compilation directives. Using the NASM pre-processor does
374 * not work, so we look for them specifically from the following list and
375 * then jam in the equivalent NASM directive into the input stream.
379 TM_ARG
, TM_ELIF
, TM_ELSE
, TM_ENDIF
, TM_IF
, TM_IFDEF
, TM_IFDIFI
,
380 TM_IFNDEF
, TM_INCLUDE
, TM_LOCAL
383 static const char * const tasm_directives
[] = {
384 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
385 "ifndef", "include", "local"
388 static int StackSize
= 4;
389 static char *StackPointer
= "ebp";
390 static int ArgOffset
= 8;
391 static int LocalOffset
= 0;
393 static Context
*cstk
;
394 static Include
*istk
;
395 static IncPath
*ipath
= NULL
;
397 static int pass
; /* HACK: pass 0 = generate dependencies only */
398 static StrList
**dephead
, **deptail
; /* Dependency list */
400 static uint64_t unique
; /* unique identifier numbers */
402 static Line
*predef
= NULL
;
403 static bool do_predef
;
405 static ListGen
*list
;
408 * The current set of multi-line macros we have defined.
410 static struct hash_table mmacros
;
413 * The current set of single-line macros we have defined.
415 static struct hash_table smacros
;
418 * The multi-line macro we are currently defining, or the %rep
419 * block we are currently reading, if any.
421 static MMacro
*defining
;
423 static uint64_t nested_mac_count
;
424 static uint64_t nested_rep_count
;
427 * The number of macro parameters to allocate space for at a time.
429 #define PARAM_DELTA 16
432 * The standard macro set: defined in macros.c in the array nasm_stdmac.
433 * This gives our position in the macro set, when we're processing it.
435 static macros_t
*stdmacpos
;
438 * The extra standard macros that come from the object format, if
441 static macros_t
*extrastdmac
= NULL
;
442 static bool any_extrastdmac
;
445 * Tokens are allocated in blocks to improve speed
447 #define TOKEN_BLOCKSIZE 4096
448 static Token
*freeTokens
= NULL
;
454 static Blocks blocks
= { NULL
, NULL
};
457 * Forward declarations.
459 static Token
*expand_mmac_params(Token
* tline
);
460 static Token
*expand_smacro(Token
* tline
);
461 static Token
*expand_id(Token
* tline
);
462 static Context
*get_ctx(const char *name
, const char **namep
);
463 static void make_tok_num(Token
* tok
, int64_t val
);
464 static void error(int severity
, const char *fmt
, ...);
465 static void error_precond(int severity
, const char *fmt
, ...);
466 static void *new_Block(size_t size
);
467 static void delete_Blocks(void);
468 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
469 const char *text
, int txtlen
);
470 static Token
*delete_Token(Token
* t
);
473 * Macros for safe checking of token pointers, avoid *(NULL)
475 #define tok_type_(x,t) ((x) && (x)->type == (t))
476 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
477 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
478 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
481 * nasm_unquote with error if the string contains NUL characters.
482 * If the string contains NUL characters, issue an error and return
483 * the C len, i.e. truncate at the NUL.
485 static size_t nasm_unquote_cstr(char *qstr
, enum preproc_token directive
)
487 size_t len
= nasm_unquote(qstr
, NULL
);
488 size_t clen
= strlen(qstr
);
491 error(ERR_NONFATAL
, "NUL character in `%s' directive",
492 pp_directives
[directive
]);
498 * In-place reverse a list of tokens.
500 static Token
*reverse_tokens(Token
*t
)
516 * Handle TASM specific directives, which do not contain a % in
517 * front of them. We do it here because I could not find any other
518 * place to do it for the moment, and it is a hack (ideally it would
519 * be nice to be able to use the NASM pre-processor to do it).
521 static char *check_tasm_directive(char *line
)
523 int32_t i
, j
, k
, m
, len
;
524 char *p
, *q
, *oldline
, oldchar
;
526 p
= nasm_skip_spaces(line
);
528 /* Binary search for the directive name */
530 j
= ARRAY_SIZE(tasm_directives
);
531 q
= nasm_skip_word(p
);
538 m
= nasm_stricmp(p
, tasm_directives
[k
]);
540 /* We have found a directive, so jam a % in front of it
541 * so that NASM will then recognise it as one if it's own.
546 line
= nasm_malloc(len
+ 2);
548 if (k
== TM_IFDIFI
) {
550 * NASM does not recognise IFDIFI, so we convert
551 * it to %if 0. This is not used in NASM
552 * compatible code, but does need to parse for the
553 * TASM macro package.
555 strcpy(line
+ 1, "if 0");
557 memcpy(line
+ 1, p
, len
+ 1);
572 * The pre-preprocessing stage... This function translates line
573 * number indications as they emerge from GNU cpp (`# lineno "file"
574 * flags') into NASM preprocessor line number indications (`%line
577 static char *prepreproc(char *line
)
580 char *fname
, *oldline
;
582 if (line
[0] == '#' && line
[1] == ' ') {
585 lineno
= atoi(fname
);
586 fname
+= strspn(fname
, "0123456789 ");
589 fnlen
= strcspn(fname
, "\"");
590 line
= nasm_malloc(20 + fnlen
);
591 snprintf(line
, 20 + fnlen
, "%%line %d %.*s", lineno
, fnlen
, fname
);
594 if (tasm_compatible_mode
)
595 return check_tasm_directive(line
);
600 * Free a linked list of tokens.
602 static void free_tlist(Token
* list
)
605 list
= delete_Token(list
);
609 * Free a linked list of lines.
611 static void free_llist(Line
* list
)
614 list_for_each_safe(l
, tmp
, list
) {
615 free_tlist(l
->first
);
623 static void free_mmacro(MMacro
* m
)
626 free_tlist(m
->dlist
);
627 nasm_free(m
->defaults
);
628 free_llist(m
->expansion
);
633 * Free all currently defined macros, and free the hash tables
635 static void free_smacro_table(struct hash_table
*smt
)
639 struct hash_tbl_node
*it
= NULL
;
641 while ((s
= hash_iterate(smt
, &it
, &key
)) != NULL
) {
642 nasm_free((void *)key
);
643 list_for_each_safe(s
, tmp
, s
) {
645 free_tlist(s
->expansion
);
652 static void free_mmacro_table(struct hash_table
*mmt
)
656 struct hash_tbl_node
*it
= NULL
;
659 while ((m
= hash_iterate(mmt
, &it
, &key
)) != NULL
) {
660 nasm_free((void *)key
);
661 list_for_each_safe(m
,tmp
, m
)
667 static void free_macros(void)
669 free_smacro_table(&smacros
);
670 free_mmacro_table(&mmacros
);
674 * Initialize the hash tables
676 static void init_macros(void)
678 hash_init(&smacros
, HASH_LARGE
);
679 hash_init(&mmacros
, HASH_LARGE
);
683 * Pop the context stack.
685 static void ctx_pop(void)
690 free_smacro_table(&c
->localmac
);
696 * Search for a key in the hash index; adding it if necessary
697 * (in which case we initialize the data pointer to NULL.)
700 hash_findi_add(struct hash_table
*hash
, const char *str
)
702 struct hash_insert hi
;
706 r
= hash_findi(hash
, str
, &hi
);
710 strx
= nasm_strdup(str
); /* Use a more efficient allocator here? */
711 return hash_add(&hi
, strx
, NULL
);
715 * Like hash_findi, but returns the data element rather than a pointer
716 * to it. Used only when not adding a new element, hence no third
720 hash_findix(struct hash_table
*hash
, const char *str
)
724 p
= hash_findi(hash
, str
, NULL
);
725 return p
? *p
: NULL
;
729 * read line from standart macros set,
730 * if there no more left -- return NULL
732 static char *line_from_stdmac(void)
735 const unsigned char *p
= stdmacpos
;
744 len
+= pp_directives_len
[c
- 0x80] + 1;
749 line
= nasm_malloc(len
+ 1);
751 while ((c
= *stdmacpos
++)) {
753 memcpy(q
, pp_directives
[c
- 0x80], pp_directives_len
[c
- 0x80]);
754 q
+= pp_directives_len
[c
- 0x80];
764 /* This was the last of the standard macro chain... */
766 if (any_extrastdmac
) {
767 stdmacpos
= extrastdmac
;
768 any_extrastdmac
= false;
769 } else if (do_predef
) {
771 Token
*head
, **tail
, *t
;
774 * Nasty hack: here we push the contents of
775 * `predef' on to the top-level expansion stack,
776 * since this is the most convenient way to
777 * implement the pre-include and pre-define
780 list_for_each(pd
, predef
) {
783 list_for_each(t
, pd
->first
) {
784 *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
785 tail
= &(*tail
)->next
;
788 l
= nasm_malloc(sizeof(Line
));
789 l
->next
= istk
->expansion
;
802 static char *read_line(void)
804 unsigned int size
, c
, next
;
805 const unsigned int delta
= 512;
806 const unsigned int pad
= 8;
807 unsigned int nr_cont
= 0;
811 /* Standart macros set (predefined) goes first */
812 p
= line_from_stdmac();
817 p
= buffer
= nasm_malloc(size
);
821 if ((int)(c
) == EOF
) {
828 next
= fgetc(istk
->fp
);
830 ungetc(next
, istk
->fp
);
845 next
= fgetc(istk
->fp
);
846 ungetc(next
, istk
->fp
);
847 if (next
== '\r' || next
== '\n') {
855 if (c
== '\r' || c
== '\n') {
860 if (p
>= (buffer
+ size
- pad
)) {
861 buffer
= nasm_realloc(buffer
, size
+ delta
);
862 p
= buffer
+ size
- pad
;
866 *p
++ = (unsigned char)c
;
874 src_set_linnum(src_get_linnum() + istk
->lineinc
+
875 (nr_cont
* istk
->lineinc
));
878 * Handle spurious ^Z, which may be inserted into source files
879 * by some file transfer utilities.
881 buffer
[strcspn(buffer
, "\032")] = '\0';
883 list
->line(LIST_READ
, buffer
);
889 * Tokenize a line of text. This is a very simple process since we
890 * don't need to parse the value out of e.g. numeric tokens: we
891 * simply split one string into many.
893 static Token
*tokenize(char *line
)
896 enum pp_token_type type
;
898 Token
*t
, **tail
= &list
;
904 if (*p
== '+' && !nasm_isdigit(p
[1])) {
907 } else if (nasm_isdigit(*p
) ||
908 ((*p
== '-' || *p
== '+') && nasm_isdigit(p
[1]))) {
912 while (nasm_isdigit(*p
));
913 type
= TOK_PREPROC_ID
;
914 } else if (*p
== '{') {
923 error(ERR_WARNING
| ERR_PASS1
, "unterminated %{ construct");
927 type
= TOK_PREPROC_ID
;
928 } else if (*p
== '[') {
930 line
+= 2; /* Skip the leading %[ */
932 while (lvl
&& (c
= *p
++)) {
944 p
= nasm_skip_string(p
- 1) + 1;
954 error(ERR_NONFATAL
, "unterminated %[ construct");
956 } else if (*p
== '?') {
957 type
= TOK_PREPROC_Q
; /* %? */
960 type
= TOK_PREPROC_QQ
; /* %?? */
963 } else if (*p
== '!') {
964 type
= TOK_PREPROC_ID
;
970 while (isidchar(*p
));
971 } else if (*p
== '\'' || *p
== '\"' || *p
== '`') {
972 p
= nasm_skip_string(p
);
976 error(ERR_NONFATAL
|ERR_PASS1
, "unterminated %! string");
978 /* %! without string or identifier */
979 type
= TOK_OTHER
; /* Legacy behavior... */
981 } else if (isidchar(*p
) ||
982 ((*p
== '!' || *p
== '%' || *p
== '$') &&
987 while (isidchar(*p
));
988 type
= TOK_PREPROC_ID
;
994 } else if (isidstart(*p
) || (*p
== '$' && isidstart(p
[1]))) {
997 while (*p
&& isidchar(*p
))
999 } else if (*p
== '\'' || *p
== '"' || *p
== '`') {
1004 p
= nasm_skip_string(p
);
1009 error(ERR_WARNING
|ERR_PASS1
, "unterminated string");
1010 /* Handling unterminated strings by UNV */
1013 } else if (p
[0] == '$' && p
[1] == '$') {
1014 type
= TOK_OTHER
; /* TOKEN_BASE */
1016 } else if (isnumstart(*p
)) {
1017 bool is_hex
= false;
1018 bool is_float
= false;
1034 if (!is_hex
&& (c
== 'e' || c
== 'E')) {
1036 if (*p
== '+' || *p
== '-') {
1038 * e can only be followed by +/- if it is either a
1039 * prefixed hex number or a floating-point number
1044 } else if (c
== 'H' || c
== 'h' || c
== 'X' || c
== 'x') {
1046 } else if (c
== 'P' || c
== 'p') {
1048 if (*p
== '+' || *p
== '-')
1050 } else if (isnumchar(c
) || c
== '_')
1051 ; /* just advance */
1052 else if (c
== '.') {
1054 * we need to deal with consequences of the legacy
1055 * parser, like "1.nolist" being two tokens
1056 * (TOK_NUMBER, TOK_ID) here; at least give it
1057 * a shot for now. In the future, we probably need
1058 * a flex-based scanner with proper pattern matching
1059 * to do it as well as it can be done. Nothing in
1060 * the world is going to help the person who wants
1061 * 0x123.p16 interpreted as two tokens, though.
1067 if (nasm_isdigit(*r
) || (is_hex
&& nasm_isxdigit(*r
)) ||
1068 (!is_hex
&& (*r
== 'e' || *r
== 'E')) ||
1069 (*r
== 'p' || *r
== 'P')) {
1073 break; /* Terminate the token */
1077 p
--; /* Point to first character beyond number */
1079 if (p
== line
+1 && *line
== '$') {
1080 type
= TOK_OTHER
; /* TOKEN_HERE */
1082 if (has_e
&& !is_hex
) {
1083 /* 1e13 is floating-point, but 1e13h is not */
1087 type
= is_float
? TOK_FLOAT
: TOK_NUMBER
;
1089 } else if (nasm_isspace(*p
)) {
1090 type
= TOK_WHITESPACE
;
1091 p
= nasm_skip_spaces(p
);
1093 * Whitespace just before end-of-line is discarded by
1094 * pretending it's a comment; whitespace just before a
1095 * comment gets lumped into the comment.
1097 if (!*p
|| *p
== ';') {
1102 } else if (*p
== ';') {
1108 * Anything else is an operator of some kind. We check
1109 * for all the double-character operators (>>, <<, //,
1110 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
1111 * else is a single-character operator.
1114 if ((p
[0] == '>' && p
[1] == '>') ||
1115 (p
[0] == '<' && p
[1] == '<') ||
1116 (p
[0] == '/' && p
[1] == '/') ||
1117 (p
[0] == '<' && p
[1] == '=') ||
1118 (p
[0] == '>' && p
[1] == '=') ||
1119 (p
[0] == '=' && p
[1] == '=') ||
1120 (p
[0] == '!' && p
[1] == '=') ||
1121 (p
[0] == '<' && p
[1] == '>') ||
1122 (p
[0] == '&' && p
[1] == '&') ||
1123 (p
[0] == '|' && p
[1] == '|') ||
1124 (p
[0] == '^' && p
[1] == '^')) {
1130 /* Handling unterminated string by UNV */
1133 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
1134 t->text[p-line] = *line;
1138 if (type
!= TOK_COMMENT
) {
1139 *tail
= t
= new_Token(NULL
, type
, line
, p
- line
);
1148 * this function allocates a new managed block of memory and
1149 * returns a pointer to the block. The managed blocks are
1150 * deleted only all at once by the delete_Blocks function.
1152 static void *new_Block(size_t size
)
1154 Blocks
*b
= &blocks
;
1156 /* first, get to the end of the linked list */
1159 /* now allocate the requested chunk */
1160 b
->chunk
= nasm_malloc(size
);
1162 /* now allocate a new block for the next request */
1163 b
->next
= nasm_malloc(sizeof(Blocks
));
1164 /* and initialize the contents of the new block */
1165 b
->next
->next
= NULL
;
1166 b
->next
->chunk
= NULL
;
1171 * this function deletes all managed blocks of memory
1173 static void delete_Blocks(void)
1175 Blocks
*a
, *b
= &blocks
;
1178 * keep in mind that the first block, pointed to by blocks
1179 * is a static and not dynamically allocated, so we don't
1184 nasm_free(b
->chunk
);
1193 * this function creates a new Token and passes a pointer to it
1194 * back to the caller. It sets the type and text elements, and
1195 * also the a.mac and next elements to NULL.
1197 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
1198 const char *text
, int txtlen
)
1204 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
1205 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
1206 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
1207 freeTokens
[i
].next
= NULL
;
1210 freeTokens
= t
->next
;
1214 if (type
== TOK_WHITESPACE
|| !text
) {
1218 txtlen
= strlen(text
);
1219 t
->text
= nasm_malloc(txtlen
+1);
1220 memcpy(t
->text
, text
, txtlen
);
1221 t
->text
[txtlen
] = '\0';
1226 static Token
*delete_Token(Token
* t
)
1228 Token
*next
= t
->next
;
1230 t
->next
= freeTokens
;
1236 * Convert a line of tokens back into text.
1237 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1238 * will be transformed into ..@ctxnum.xxx
1240 static char *detoken(Token
* tlist
, bool expand_locals
)
1247 list_for_each(t
, tlist
) {
1248 if (t
->type
== TOK_PREPROC_ID
&& t
->text
[1] == '!') {
1253 if (*v
== '\'' || *v
== '\"' || *v
== '`') {
1254 size_t len
= nasm_unquote(v
, NULL
);
1255 size_t clen
= strlen(v
);
1258 error(ERR_NONFATAL
| ERR_PASS1
,
1259 "NUL character in %! string");
1265 char *p
= getenv(v
);
1267 error(ERR_NONFATAL
| ERR_PASS1
,
1268 "nonexistent environment variable `%s'", v
);
1271 t
->text
= nasm_strdup(p
);
1276 /* Expand local macros here and not during preprocessing */
1277 if (expand_locals
&&
1278 t
->type
== TOK_PREPROC_ID
&& t
->text
&&
1279 t
->text
[0] == '%' && t
->text
[1] == '$') {
1282 Context
*ctx
= get_ctx(t
->text
, &q
);
1285 snprintf(buffer
, sizeof(buffer
), "..@%"PRIu32
".", ctx
->number
);
1286 p
= nasm_strcat(buffer
, q
);
1291 if (t
->type
== TOK_WHITESPACE
)
1294 len
+= strlen(t
->text
);
1297 p
= line
= nasm_malloc(len
+ 1);
1299 list_for_each(t
, tlist
) {
1300 if (t
->type
== TOK_WHITESPACE
) {
1302 } else if (t
->text
) {
1314 * A scanner, suitable for use by the expression evaluator, which
1315 * operates on a line of Tokens. Expects a pointer to a pointer to
1316 * the first token in the line to be passed in as its private_data
1319 * FIX: This really needs to be unified with stdscan.
1321 static int ppscan(void *private_data
, struct tokenval
*tokval
)
1323 Token
**tlineptr
= private_data
;
1325 char ourcopy
[MAX_KEYWORD
+1], *p
, *r
, *s
;
1329 *tlineptr
= tline
? tline
->next
: NULL
;
1330 } while (tline
&& (tline
->type
== TOK_WHITESPACE
||
1331 tline
->type
== TOK_COMMENT
));
1334 return tokval
->t_type
= TOKEN_EOS
;
1336 tokval
->t_charptr
= tline
->text
;
1338 if (tline
->text
[0] == '$' && !tline
->text
[1])
1339 return tokval
->t_type
= TOKEN_HERE
;
1340 if (tline
->text
[0] == '$' && tline
->text
[1] == '$' && !tline
->text
[2])
1341 return tokval
->t_type
= TOKEN_BASE
;
1343 if (tline
->type
== TOK_ID
) {
1344 p
= tokval
->t_charptr
= tline
->text
;
1346 tokval
->t_charptr
++;
1347 return tokval
->t_type
= TOKEN_ID
;
1350 for (r
= p
, s
= ourcopy
; *r
; r
++) {
1351 if (r
>= p
+MAX_KEYWORD
)
1352 return tokval
->t_type
= TOKEN_ID
; /* Not a keyword */
1353 *s
++ = nasm_tolower(*r
);
1356 /* right, so we have an identifier sitting in temp storage. now,
1357 * is it actually a register or instruction name, or what? */
1358 return nasm_token_hash(ourcopy
, tokval
);
1361 if (tline
->type
== TOK_NUMBER
) {
1363 tokval
->t_integer
= readnum(tline
->text
, &rn_error
);
1364 tokval
->t_charptr
= tline
->text
;
1366 return tokval
->t_type
= TOKEN_ERRNUM
;
1368 return tokval
->t_type
= TOKEN_NUM
;
1371 if (tline
->type
== TOK_FLOAT
) {
1372 return tokval
->t_type
= TOKEN_FLOAT
;
1375 if (tline
->type
== TOK_STRING
) {
1378 bq
= tline
->text
[0];
1379 tokval
->t_charptr
= tline
->text
;
1380 tokval
->t_inttwo
= nasm_unquote(tline
->text
, &ep
);
1382 if (ep
[0] != bq
|| ep
[1] != '\0')
1383 return tokval
->t_type
= TOKEN_ERRSTR
;
1385 return tokval
->t_type
= TOKEN_STR
;
1388 if (tline
->type
== TOK_OTHER
) {
1389 if (!strcmp(tline
->text
, "<<"))
1390 return tokval
->t_type
= TOKEN_SHL
;
1391 if (!strcmp(tline
->text
, ">>"))
1392 return tokval
->t_type
= TOKEN_SHR
;
1393 if (!strcmp(tline
->text
, "//"))
1394 return tokval
->t_type
= TOKEN_SDIV
;
1395 if (!strcmp(tline
->text
, "%%"))
1396 return tokval
->t_type
= TOKEN_SMOD
;
1397 if (!strcmp(tline
->text
, "=="))
1398 return tokval
->t_type
= TOKEN_EQ
;
1399 if (!strcmp(tline
->text
, "<>"))
1400 return tokval
->t_type
= TOKEN_NE
;
1401 if (!strcmp(tline
->text
, "!="))
1402 return tokval
->t_type
= TOKEN_NE
;
1403 if (!strcmp(tline
->text
, "<="))
1404 return tokval
->t_type
= TOKEN_LE
;
1405 if (!strcmp(tline
->text
, ">="))
1406 return tokval
->t_type
= TOKEN_GE
;
1407 if (!strcmp(tline
->text
, "&&"))
1408 return tokval
->t_type
= TOKEN_DBL_AND
;
1409 if (!strcmp(tline
->text
, "^^"))
1410 return tokval
->t_type
= TOKEN_DBL_XOR
;
1411 if (!strcmp(tline
->text
, "||"))
1412 return tokval
->t_type
= TOKEN_DBL_OR
;
1416 * We have no other options: just return the first character of
1419 return tokval
->t_type
= tline
->text
[0];
1423 * Compare a string to the name of an existing macro; this is a
1424 * simple wrapper which calls either strcmp or nasm_stricmp
1425 * depending on the value of the `casesense' parameter.
1427 static int mstrcmp(const char *p
, const char *q
, bool casesense
)
1429 return casesense
? strcmp(p
, q
) : nasm_stricmp(p
, q
);
1433 * Compare a string to the name of an existing macro; this is a
1434 * simple wrapper which calls either strcmp or nasm_stricmp
1435 * depending on the value of the `casesense' parameter.
1437 static int mmemcmp(const char *p
, const char *q
, size_t l
, bool casesense
)
1439 return casesense
? memcmp(p
, q
, l
) : nasm_memicmp(p
, q
, l
);
1443 * Return the Context structure associated with a %$ token. Return
1444 * NULL, having _already_ reported an error condition, if the
1445 * context stack isn't deep enough for the supplied number of $
1448 * If "namep" is non-NULL, set it to the pointer to the macro name
1449 * tail, i.e. the part beyond %$...
1451 static Context
*get_ctx(const char *name
, const char **namep
)
1459 if (!name
|| name
[0] != '%' || name
[1] != '$')
1463 error(ERR_NONFATAL
, "`%s': context stack is empty", name
);
1470 while (ctx
&& *name
== '$') {
1476 error(ERR_NONFATAL
, "`%s': context stack is only"
1477 " %d level%s deep", name
, i
, (i
== 1 ? "" : "s"));
1488 * Check to see if a file is already in a string list
1490 static bool in_list(const StrList
*list
, const char *str
)
1493 if (!strcmp(list
->str
, str
))
1501 * Open an include file. This routine must always return a valid
1502 * file pointer if it returns - it's responsible for throwing an
1503 * ERR_FATAL and bombing out completely if not. It should also try
1504 * the include path one by one until it finds the file or reaches
1505 * the end of the path.
1507 static FILE *inc_fopen(const char *file
, StrList
**dhead
, StrList
***dtail
,
1512 IncPath
*ip
= ipath
;
1513 int len
= strlen(file
);
1514 size_t prefix_len
= 0;
1518 sl
= nasm_malloc(prefix_len
+len
+1+sizeof sl
->next
);
1519 memcpy(sl
->str
, prefix
, prefix_len
);
1520 memcpy(sl
->str
+prefix_len
, file
, len
+1);
1521 fp
= fopen(sl
->str
, "r");
1522 if (fp
&& dhead
&& !in_list(*dhead
, sl
->str
)) {
1540 prefix_len
= strlen(prefix
);
1542 /* -MG given and file not found */
1543 if (dhead
&& !in_list(*dhead
, file
)) {
1544 sl
= nasm_malloc(len
+1+sizeof sl
->next
);
1546 strcpy(sl
->str
, file
);
1554 error(ERR_FATAL
, "unable to open include file `%s'", file
);
1559 * Determine if we should warn on defining a single-line macro of
1560 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1561 * return true if _any_ single-line macro of that name is defined.
1562 * Otherwise, will return true if a single-line macro with either
1563 * `nparam' or no parameters is defined.
1565 * If a macro with precisely the right number of parameters is
1566 * defined, or nparam is -1, the address of the definition structure
1567 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1568 * is NULL, no action will be taken regarding its contents, and no
1571 * Note that this is also called with nparam zero to resolve
1574 * If you already know which context macro belongs to, you can pass
1575 * the context pointer as first parameter; if you won't but name begins
1576 * with %$ the context will be automatically computed. If all_contexts
1577 * is true, macro will be searched in outer contexts as well.
1580 smacro_defined(Context
* ctx
, const char *name
, int nparam
, SMacro
** defn
,
1583 struct hash_table
*smtbl
;
1587 smtbl
= &ctx
->localmac
;
1588 } else if (name
[0] == '%' && name
[1] == '$') {
1590 ctx
= get_ctx(name
, &name
);
1592 return false; /* got to return _something_ */
1593 smtbl
= &ctx
->localmac
;
1597 m
= (SMacro
*) hash_findix(smtbl
, name
);
1600 if (!mstrcmp(m
->name
, name
, m
->casesense
&& nocase
) &&
1601 (nparam
<= 0 || m
->nparam
== 0 || nparam
== (int) m
->nparam
)) {
1603 if (nparam
== (int) m
->nparam
|| nparam
== -1)
1617 * Count and mark off the parameters in a multi-line macro call.
1618 * This is called both from within the multi-line macro expansion
1619 * code, and also to mark off the default parameters when provided
1620 * in a %macro definition line.
1622 static void count_mmac_params(Token
* t
, int *nparam
, Token
*** params
)
1624 int paramsize
, brace
;
1626 *nparam
= paramsize
= 0;
1629 /* +1: we need space for the final NULL */
1630 if (*nparam
+1 >= paramsize
) {
1631 paramsize
+= PARAM_DELTA
;
1632 *params
= nasm_realloc(*params
, sizeof(**params
) * paramsize
);
1636 if (tok_is_(t
, "{"))
1638 (*params
)[(*nparam
)++] = t
;
1639 while (tok_isnt_(t
, brace
? "}" : ","))
1641 if (t
) { /* got a comma/brace */
1645 * Now we've found the closing brace, look further
1649 if (tok_isnt_(t
, ",")) {
1651 "braces do not enclose all of macro parameter");
1652 while (tok_isnt_(t
, ","))
1656 t
= t
->next
; /* eat the comma */
1663 * Determine whether one of the various `if' conditions is true or
1666 * We must free the tline we get passed.
1668 static bool if_condition(Token
* tline
, enum preproc_token ct
)
1670 enum pp_conditional i
= PP_COND(ct
);
1672 Token
*t
, *tt
, **tptr
, *origline
;
1673 struct tokenval tokval
;
1675 enum pp_token_type needtype
;
1682 j
= false; /* have we matched yet? */
1687 if (tline
->type
!= TOK_ID
) {
1689 "`%s' expects context identifiers", pp_directives
[ct
]);
1690 free_tlist(origline
);
1693 if (cstk
&& cstk
->name
&& !nasm_stricmp(tline
->text
, cstk
->name
))
1695 tline
= tline
->next
;
1700 j
= false; /* have we matched yet? */
1703 if (!tline
|| (tline
->type
!= TOK_ID
&&
1704 (tline
->type
!= TOK_PREPROC_ID
||
1705 tline
->text
[1] != '$'))) {
1707 "`%s' expects macro identifiers", pp_directives
[ct
]);
1710 if (smacro_defined(NULL
, tline
->text
, 0, NULL
, true))
1712 tline
= tline
->next
;
1717 tline
= expand_smacro(tline
);
1718 j
= false; /* have we matched yet? */
1721 if (!tline
|| (tline
->type
!= TOK_ID
&&
1722 tline
->type
!= TOK_STRING
&&
1723 (tline
->type
!= TOK_PREPROC_ID
||
1724 tline
->text
[1] != '!'))) {
1726 "`%s' expects environment variable names",
1731 if (tline
->type
== TOK_PREPROC_ID
)
1732 p
+= 2; /* Skip leading %! */
1733 if (*p
== '\'' || *p
== '\"' || *p
== '`')
1734 nasm_unquote_cstr(p
, ct
);
1737 tline
= tline
->next
;
1743 tline
= expand_smacro(tline
);
1745 while (tok_isnt_(tt
, ","))
1749 "`%s' expects two comma-separated arguments",
1754 j
= true; /* assume equality unless proved not */
1755 while ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) && tt
) {
1756 if (tt
->type
== TOK_OTHER
&& !strcmp(tt
->text
, ",")) {
1757 error(ERR_NONFATAL
, "`%s': more than one comma on line",
1761 if (t
->type
== TOK_WHITESPACE
) {
1765 if (tt
->type
== TOK_WHITESPACE
) {
1769 if (tt
->type
!= t
->type
) {
1770 j
= false; /* found mismatching tokens */
1773 /* When comparing strings, need to unquote them first */
1774 if (t
->type
== TOK_STRING
) {
1775 size_t l1
= nasm_unquote(t
->text
, NULL
);
1776 size_t l2
= nasm_unquote(tt
->text
, NULL
);
1782 if (mmemcmp(t
->text
, tt
->text
, l1
, i
== PPC_IFIDN
)) {
1786 } else if (mstrcmp(tt
->text
, t
->text
, i
== PPC_IFIDN
) != 0) {
1787 j
= false; /* found mismatching tokens */
1794 if ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) || tt
)
1795 j
= false; /* trailing gunk on one end or other */
1801 MMacro searching
, *mmac
;
1804 tline
= expand_id(tline
);
1805 if (!tok_type_(tline
, TOK_ID
)) {
1807 "`%s' expects a macro name", pp_directives
[ct
]);
1810 searching
.name
= nasm_strdup(tline
->text
);
1811 searching
.casesense
= true;
1812 searching
.plus
= false;
1813 searching
.nolist
= false;
1814 searching
.in_progress
= 0;
1815 searching
.max_depth
= 0;
1816 searching
.rep_nest
= NULL
;
1817 searching
.nparam_min
= 0;
1818 searching
.nparam_max
= INT_MAX
;
1819 tline
= expand_smacro(tline
->next
);
1822 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
1824 "`%s' expects a parameter count or nothing",
1827 searching
.nparam_min
= searching
.nparam_max
=
1828 readnum(tline
->text
, &j
);
1831 "unable to parse parameter count `%s'",
1834 if (tline
&& tok_is_(tline
->next
, "-")) {
1835 tline
= tline
->next
->next
;
1836 if (tok_is_(tline
, "*"))
1837 searching
.nparam_max
= INT_MAX
;
1838 else if (!tok_type_(tline
, TOK_NUMBER
))
1840 "`%s' expects a parameter count after `-'",
1843 searching
.nparam_max
= readnum(tline
->text
, &j
);
1846 "unable to parse parameter count `%s'",
1848 if (searching
.nparam_min
> searching
.nparam_max
)
1850 "minimum parameter count exceeds maximum");
1853 if (tline
&& tok_is_(tline
->next
, "+")) {
1854 tline
= tline
->next
;
1855 searching
.plus
= true;
1857 mmac
= (MMacro
*) hash_findix(&mmacros
, searching
.name
);
1859 if (!strcmp(mmac
->name
, searching
.name
) &&
1860 (mmac
->nparam_min
<= searching
.nparam_max
1862 && (searching
.nparam_min
<= mmac
->nparam_max
1869 if (tline
&& tline
->next
)
1870 error(ERR_WARNING
|ERR_PASS1
,
1871 "trailing garbage after %%ifmacro ignored");
1872 nasm_free(searching
.name
);
1881 needtype
= TOK_NUMBER
;
1884 needtype
= TOK_STRING
;
1888 t
= tline
= expand_smacro(tline
);
1890 while (tok_type_(t
, TOK_WHITESPACE
) ||
1891 (needtype
== TOK_NUMBER
&&
1892 tok_type_(t
, TOK_OTHER
) &&
1893 (t
->text
[0] == '-' || t
->text
[0] == '+') &&
1897 j
= tok_type_(t
, needtype
);
1901 t
= tline
= expand_smacro(tline
);
1902 while (tok_type_(t
, TOK_WHITESPACE
))
1907 t
= t
->next
; /* Skip the actual token */
1908 while (tok_type_(t
, TOK_WHITESPACE
))
1910 j
= !t
; /* Should be nothing left */
1915 t
= tline
= expand_smacro(tline
);
1916 while (tok_type_(t
, TOK_WHITESPACE
))
1919 j
= !t
; /* Should be empty */
1923 t
= tline
= expand_smacro(tline
);
1925 tokval
.t_type
= TOKEN_INVALID
;
1926 evalresult
= evaluate(ppscan
, tptr
, &tokval
,
1927 NULL
, pass
| CRITICAL
, error
, NULL
);
1931 error(ERR_WARNING
|ERR_PASS1
,
1932 "trailing garbage after expression ignored");
1933 if (!is_simple(evalresult
)) {
1935 "non-constant value given to `%s'", pp_directives
[ct
]);
1938 j
= reloc_value(evalresult
) != 0;
1943 "preprocessor directive `%s' not yet implemented",
1948 free_tlist(origline
);
1949 return j
^ PP_NEGATIVE(ct
);
1952 free_tlist(origline
);
1957 * Common code for defining an smacro
1959 static bool define_smacro(Context
*ctx
, const char *mname
, bool casesense
,
1960 int nparam
, Token
*expansion
)
1962 SMacro
*smac
, **smhead
;
1963 struct hash_table
*smtbl
;
1965 if (smacro_defined(ctx
, mname
, nparam
, &smac
, casesense
)) {
1967 error(ERR_WARNING
|ERR_PASS1
,
1968 "single-line macro `%s' defined both with and"
1969 " without parameters", mname
);
1971 * Some instances of the old code considered this a failure,
1972 * some others didn't. What is the right thing to do here?
1974 free_tlist(expansion
);
1975 return false; /* Failure */
1978 * We're redefining, so we have to take over an
1979 * existing SMacro structure. This means freeing
1980 * what was already in it.
1982 nasm_free(smac
->name
);
1983 free_tlist(smac
->expansion
);
1986 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1987 smhead
= (SMacro
**) hash_findi_add(smtbl
, mname
);
1988 smac
= nasm_malloc(sizeof(SMacro
));
1989 smac
->next
= *smhead
;
1992 smac
->name
= nasm_strdup(mname
);
1993 smac
->casesense
= casesense
;
1994 smac
->nparam
= nparam
;
1995 smac
->expansion
= expansion
;
1996 smac
->in_progress
= false;
1997 return true; /* Success */
2001 * Undefine an smacro
2003 static void undef_smacro(Context
*ctx
, const char *mname
)
2005 SMacro
**smhead
, *s
, **sp
;
2006 struct hash_table
*smtbl
;
2008 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
2009 smhead
= (SMacro
**)hash_findi(smtbl
, mname
, NULL
);
2013 * We now have a macro name... go hunt for it.
2016 while ((s
= *sp
) != NULL
) {
2017 if (!mstrcmp(s
->name
, mname
, s
->casesense
)) {
2020 free_tlist(s
->expansion
);
2030 * Parse a mmacro specification.
2032 static bool parse_mmacro_spec(Token
*tline
, MMacro
*def
, const char *directive
)
2036 tline
= tline
->next
;
2038 tline
= expand_id(tline
);
2039 if (!tok_type_(tline
, TOK_ID
)) {
2040 error(ERR_NONFATAL
, "`%s' expects a macro name", directive
);
2045 def
->name
= nasm_strdup(tline
->text
);
2047 def
->nolist
= false;
2048 def
->in_progress
= 0;
2049 def
->rep_nest
= NULL
;
2050 def
->nparam_min
= 0;
2051 def
->nparam_max
= 0;
2053 tline
= expand_smacro(tline
->next
);
2055 if (!tok_type_(tline
, TOK_NUMBER
)) {
2056 error(ERR_NONFATAL
, "`%s' expects a parameter count", directive
);
2058 def
->nparam_min
= def
->nparam_max
=
2059 readnum(tline
->text
, &err
);
2062 "unable to parse parameter count `%s'", tline
->text
);
2064 if (tline
&& tok_is_(tline
->next
, "-")) {
2065 tline
= tline
->next
->next
;
2066 if (tok_is_(tline
, "*")) {
2067 def
->nparam_max
= INT_MAX
;
2068 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
2070 "`%s' expects a parameter count after `-'", directive
);
2072 def
->nparam_max
= readnum(tline
->text
, &err
);
2074 error(ERR_NONFATAL
, "unable to parse parameter count `%s'",
2077 if (def
->nparam_min
> def
->nparam_max
) {
2078 error(ERR_NONFATAL
, "minimum parameter count exceeds maximum");
2082 if (tline
&& tok_is_(tline
->next
, "+")) {
2083 tline
= tline
->next
;
2086 if (tline
&& tok_type_(tline
->next
, TOK_ID
) &&
2087 !nasm_stricmp(tline
->next
->text
, ".nolist")) {
2088 tline
= tline
->next
;
2093 * Handle default parameters.
2095 if (tline
&& tline
->next
) {
2096 def
->dlist
= tline
->next
;
2098 count_mmac_params(def
->dlist
, &def
->ndefs
, &def
->defaults
);
2101 def
->defaults
= NULL
;
2103 def
->expansion
= NULL
;
2105 if (def
->defaults
&& def
->ndefs
> def
->nparam_max
- def
->nparam_min
&&
2107 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MDP
,
2108 "too many default macro parameters");
2115 * Decode a size directive
2117 static int parse_size(const char *str
) {
2118 static const char *size_names
[] =
2119 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
2120 static const int sizes
[] =
2121 { 0, 1, 4, 16, 8, 10, 2, 32 };
2123 return sizes
[bsii(str
, size_names
, ARRAY_SIZE(size_names
))+1];
2127 * find and process preprocessor directive in passed line
2128 * Find out if a line contains a preprocessor directive, and deal
2131 * If a directive _is_ found, it is the responsibility of this routine
2132 * (and not the caller) to free_tlist() the line.
2134 * @param tline a pointer to the current tokeninzed line linked list
2135 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
2138 static int do_directive(Token
* tline
)
2140 enum preproc_token i
;
2153 MMacro
*mmac
, **mmhead
;
2154 Token
*t
, *tt
, *param_start
, *macro_start
, *last
, **tptr
, *origline
;
2156 struct tokenval tokval
;
2158 MMacro
*tmp_defining
; /* Used when manipulating rep_nest */
2166 if (!tline
|| !tok_type_(tline
, TOK_PREPROC_ID
) ||
2167 (tline
->text
[1] == '%' || tline
->text
[1] == '$'
2168 || tline
->text
[1] == '!'))
2169 return NO_DIRECTIVE_FOUND
;
2171 i
= pp_token_hash(tline
->text
);
2174 * FIXME: We zap execution of PP_RMACRO, PP_IRMACRO, PP_EXITMACRO
2175 * since they are known to be buggy at moment, we need to fix them
2176 * in future release (2.09-2.10)
2178 if (i
== PP_RMACRO
|| i
== PP_RMACRO
|| i
== PP_EXITMACRO
) {
2179 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
2181 return NO_DIRECTIVE_FOUND
;
2185 * If we're in a non-emitting branch of a condition construct,
2186 * or walking to the end of an already terminated %rep block,
2187 * we should ignore all directives except for condition
2190 if (((istk
->conds
&& !emitting(istk
->conds
->state
)) ||
2191 (istk
->mstk
&& !istk
->mstk
->in_progress
)) && !is_condition(i
)) {
2192 return NO_DIRECTIVE_FOUND
;
2196 * If we're defining a macro or reading a %rep block, we should
2197 * ignore all directives except for %macro/%imacro (which nest),
2198 * %endm/%endmacro, and (only if we're in a %rep block) %endrep.
2199 * If we're in a %rep block, another %rep nests, so should be let through.
2201 if (defining
&& i
!= PP_MACRO
&& i
!= PP_IMACRO
&&
2202 i
!= PP_RMACRO
&& i
!= PP_IRMACRO
&&
2203 i
!= PP_ENDMACRO
&& i
!= PP_ENDM
&&
2204 (defining
->name
|| (i
!= PP_ENDREP
&& i
!= PP_REP
))) {
2205 return NO_DIRECTIVE_FOUND
;
2209 if (i
== PP_MACRO
|| i
== PP_IMACRO
||
2210 i
== PP_RMACRO
|| i
== PP_IRMACRO
) {
2212 return NO_DIRECTIVE_FOUND
;
2213 } else if (nested_mac_count
> 0) {
2214 if (i
== PP_ENDMACRO
) {
2216 return NO_DIRECTIVE_FOUND
;
2219 if (!defining
->name
) {
2222 return NO_DIRECTIVE_FOUND
;
2223 } else if (nested_rep_count
> 0) {
2224 if (i
== PP_ENDREP
) {
2226 return NO_DIRECTIVE_FOUND
;
2234 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
2236 return NO_DIRECTIVE_FOUND
; /* didn't get it */
2239 /* Directive to tell NASM what the default stack size is. The
2240 * default is for a 16-bit stack, and this can be overriden with
2243 tline
= tline
->next
;
2244 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2245 tline
= tline
->next
;
2246 if (!tline
|| tline
->type
!= TOK_ID
) {
2247 error(ERR_NONFATAL
, "`%%stacksize' missing size parameter");
2248 free_tlist(origline
);
2249 return DIRECTIVE_FOUND
;
2251 if (nasm_stricmp(tline
->text
, "flat") == 0) {
2252 /* All subsequent ARG directives are for a 32-bit stack */
2254 StackPointer
= "ebp";
2257 } else if (nasm_stricmp(tline
->text
, "flat64") == 0) {
2258 /* All subsequent ARG directives are for a 64-bit stack */
2260 StackPointer
= "rbp";
2263 } else if (nasm_stricmp(tline
->text
, "large") == 0) {
2264 /* All subsequent ARG directives are for a 16-bit stack,
2265 * far function call.
2268 StackPointer
= "bp";
2271 } else if (nasm_stricmp(tline
->text
, "small") == 0) {
2272 /* All subsequent ARG directives are for a 16-bit stack,
2273 * far function call. We don't support near functions.
2276 StackPointer
= "bp";
2280 error(ERR_NONFATAL
, "`%%stacksize' invalid size type");
2281 free_tlist(origline
);
2282 return DIRECTIVE_FOUND
;
2284 free_tlist(origline
);
2285 return DIRECTIVE_FOUND
;
2288 /* TASM like ARG directive to define arguments to functions, in
2289 * the following form:
2291 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2295 char *arg
, directive
[256];
2296 int size
= StackSize
;
2298 /* Find the argument name */
2299 tline
= tline
->next
;
2300 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2301 tline
= tline
->next
;
2302 if (!tline
|| tline
->type
!= TOK_ID
) {
2303 error(ERR_NONFATAL
, "`%%arg' missing argument parameter");
2304 free_tlist(origline
);
2305 return DIRECTIVE_FOUND
;
2309 /* Find the argument size type */
2310 tline
= tline
->next
;
2311 if (!tline
|| tline
->type
!= TOK_OTHER
2312 || tline
->text
[0] != ':') {
2314 "Syntax error processing `%%arg' directive");
2315 free_tlist(origline
);
2316 return DIRECTIVE_FOUND
;
2318 tline
= tline
->next
;
2319 if (!tline
|| tline
->type
!= TOK_ID
) {
2320 error(ERR_NONFATAL
, "`%%arg' missing size type parameter");
2321 free_tlist(origline
);
2322 return DIRECTIVE_FOUND
;
2325 /* Allow macro expansion of type parameter */
2326 tt
= tokenize(tline
->text
);
2327 tt
= expand_smacro(tt
);
2328 size
= parse_size(tt
->text
);
2331 "Invalid size type for `%%arg' missing directive");
2333 free_tlist(origline
);
2334 return DIRECTIVE_FOUND
;
2338 /* Round up to even stack slots */
2339 size
= ALIGN(size
, StackSize
);
2341 /* Now define the macro for the argument */
2342 snprintf(directive
, sizeof(directive
), "%%define %s (%s+%d)",
2343 arg
, StackPointer
, offset
);
2344 do_directive(tokenize(directive
));
2347 /* Move to the next argument in the list */
2348 tline
= tline
->next
;
2349 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2350 tline
= tline
->next
;
2351 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2353 free_tlist(origline
);
2354 return DIRECTIVE_FOUND
;
2357 /* TASM like LOCAL directive to define local variables for a
2358 * function, in the following form:
2360 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2362 * The '= LocalSize' at the end is ignored by NASM, but is
2363 * required by TASM to define the local parameter size (and used
2364 * by the TASM macro package).
2366 offset
= LocalOffset
;
2368 char *local
, directive
[256];
2369 int size
= StackSize
;
2371 /* Find the argument name */
2372 tline
= tline
->next
;
2373 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2374 tline
= tline
->next
;
2375 if (!tline
|| tline
->type
!= TOK_ID
) {
2377 "`%%local' missing argument parameter");
2378 free_tlist(origline
);
2379 return DIRECTIVE_FOUND
;
2381 local
= tline
->text
;
2383 /* Find the argument size type */
2384 tline
= tline
->next
;
2385 if (!tline
|| tline
->type
!= TOK_OTHER
2386 || tline
->text
[0] != ':') {
2388 "Syntax error processing `%%local' directive");
2389 free_tlist(origline
);
2390 return DIRECTIVE_FOUND
;
2392 tline
= tline
->next
;
2393 if (!tline
|| tline
->type
!= TOK_ID
) {
2395 "`%%local' missing size type parameter");
2396 free_tlist(origline
);
2397 return DIRECTIVE_FOUND
;
2400 /* Allow macro expansion of type parameter */
2401 tt
= tokenize(tline
->text
);
2402 tt
= expand_smacro(tt
);
2403 size
= parse_size(tt
->text
);
2406 "Invalid size type for `%%local' missing directive");
2408 free_tlist(origline
);
2409 return DIRECTIVE_FOUND
;
2413 /* Round up to even stack slots */
2414 size
= ALIGN(size
, StackSize
);
2416 offset
+= size
; /* Negative offset, increment before */
2418 /* Now define the macro for the argument */
2419 snprintf(directive
, sizeof(directive
), "%%define %s (%s-%d)",
2420 local
, StackPointer
, offset
);
2421 do_directive(tokenize(directive
));
2423 /* Now define the assign to setup the enter_c macro correctly */
2424 snprintf(directive
, sizeof(directive
),
2425 "%%assign %%$localsize %%$localsize+%d", size
);
2426 do_directive(tokenize(directive
));
2428 /* Move to the next argument in the list */
2429 tline
= tline
->next
;
2430 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2431 tline
= tline
->next
;
2432 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2433 LocalOffset
= offset
;
2434 free_tlist(origline
);
2435 return DIRECTIVE_FOUND
;
2439 error(ERR_WARNING
|ERR_PASS1
,
2440 "trailing garbage after `%%clear' ignored");
2443 free_tlist(origline
);
2444 return DIRECTIVE_FOUND
;
2447 t
= tline
->next
= expand_smacro(tline
->next
);
2449 if (!t
|| (t
->type
!= TOK_STRING
&&
2450 t
->type
!= TOK_INTERNAL_STRING
)) {
2451 error(ERR_NONFATAL
, "`%%depend' expects a file name");
2452 free_tlist(origline
);
2453 return DIRECTIVE_FOUND
; /* but we did _something_ */
2456 error(ERR_WARNING
|ERR_PASS1
,
2457 "trailing garbage after `%%depend' ignored");
2459 if (t
->type
!= TOK_INTERNAL_STRING
)
2460 nasm_unquote_cstr(p
, i
);
2461 if (dephead
&& !in_list(*dephead
, p
)) {
2462 StrList
*sl
= nasm_malloc(strlen(p
)+1+sizeof sl
->next
);
2466 deptail
= &sl
->next
;
2468 free_tlist(origline
);
2469 return DIRECTIVE_FOUND
;
2472 t
= tline
->next
= expand_smacro(tline
->next
);
2475 if (!t
|| (t
->type
!= TOK_STRING
&&
2476 t
->type
!= TOK_INTERNAL_STRING
)) {
2477 error(ERR_NONFATAL
, "`%%include' expects a file name");
2478 free_tlist(origline
);
2479 return DIRECTIVE_FOUND
; /* but we did _something_ */
2482 error(ERR_WARNING
|ERR_PASS1
,
2483 "trailing garbage after `%%include' ignored");
2485 if (t
->type
!= TOK_INTERNAL_STRING
)
2486 nasm_unquote_cstr(p
, i
);
2487 inc
= nasm_malloc(sizeof(Include
));
2490 inc
->fp
= inc_fopen(p
, dephead
, &deptail
, pass
== 0);
2492 /* -MG given but file not found */
2495 inc
->fname
= src_set_fname(nasm_strdup(p
));
2496 inc
->lineno
= src_set_linnum(0);
2498 inc
->expansion
= NULL
;
2501 list
->uplevel(LIST_INCLUDE
);
2503 free_tlist(origline
);
2504 return DIRECTIVE_FOUND
;
2508 static macros_t
*use_pkg
;
2509 const char *pkg_macro
= NULL
;
2511 tline
= tline
->next
;
2513 tline
= expand_id(tline
);
2515 if (!tline
|| (tline
->type
!= TOK_STRING
&&
2516 tline
->type
!= TOK_INTERNAL_STRING
&&
2517 tline
->type
!= TOK_ID
)) {
2518 error(ERR_NONFATAL
, "`%%use' expects a package name");
2519 free_tlist(origline
);
2520 return DIRECTIVE_FOUND
; /* but we did _something_ */
2523 error(ERR_WARNING
|ERR_PASS1
,
2524 "trailing garbage after `%%use' ignored");
2525 if (tline
->type
== TOK_STRING
)
2526 nasm_unquote_cstr(tline
->text
, i
);
2527 use_pkg
= nasm_stdmac_find_package(tline
->text
);
2529 error(ERR_NONFATAL
, "unknown `%%use' package: %s", tline
->text
);
2531 pkg_macro
= (char *)use_pkg
+ 1; /* The first string will be <%define>__USE_*__ */
2532 if (use_pkg
&& ! smacro_defined(NULL
, pkg_macro
, 0, NULL
, true)) {
2533 /* Not already included, go ahead and include it */
2534 stdmacpos
= use_pkg
;
2536 free_tlist(origline
);
2537 return DIRECTIVE_FOUND
;
2542 tline
= tline
->next
;
2544 tline
= expand_id(tline
);
2546 if (!tok_type_(tline
, TOK_ID
)) {
2547 error(ERR_NONFATAL
, "`%s' expects a context identifier",
2549 free_tlist(origline
);
2550 return DIRECTIVE_FOUND
; /* but we did _something_ */
2553 error(ERR_WARNING
|ERR_PASS1
,
2554 "trailing garbage after `%s' ignored",
2556 p
= nasm_strdup(tline
->text
);
2558 p
= NULL
; /* Anonymous */
2562 ctx
= nasm_malloc(sizeof(Context
));
2564 hash_init(&ctx
->localmac
, HASH_SMALL
);
2566 ctx
->number
= unique
++;
2571 error(ERR_NONFATAL
, "`%s': context stack is empty",
2573 } else if (i
== PP_POP
) {
2574 if (p
&& (!cstk
->name
|| nasm_stricmp(p
, cstk
->name
)))
2575 error(ERR_NONFATAL
, "`%%pop' in wrong context: %s, "
2577 cstk
->name
? cstk
->name
: "anonymous", p
);
2582 nasm_free(cstk
->name
);
2588 free_tlist(origline
);
2589 return DIRECTIVE_FOUND
;
2591 severity
= ERR_FATAL
;
2594 severity
= ERR_NONFATAL
;
2597 severity
= ERR_WARNING
|ERR_WARN_USER
;
2602 /* Only error out if this is the final pass */
2603 if (pass
!= 2 && i
!= PP_FATAL
)
2604 return DIRECTIVE_FOUND
;
2606 tline
->next
= expand_smacro(tline
->next
);
2607 tline
= tline
->next
;
2609 t
= tline
? tline
->next
: NULL
;
2611 if (tok_type_(tline
, TOK_STRING
) && !t
) {
2612 /* The line contains only a quoted string */
2614 nasm_unquote(p
, NULL
); /* Ignore NUL character truncation */
2615 error(severity
, "%s", p
);
2617 /* Not a quoted string, or more than a quoted string */
2618 p
= detoken(tline
, false);
2619 error(severity
, "%s", p
);
2622 free_tlist(origline
);
2623 return DIRECTIVE_FOUND
;
2627 if (istk
->conds
&& !emitting(istk
->conds
->state
))
2630 j
= if_condition(tline
->next
, i
);
2631 tline
->next
= NULL
; /* it got freed */
2632 j
= j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2634 cond
= nasm_malloc(sizeof(Cond
));
2635 cond
->next
= istk
->conds
;
2639 istk
->mstk
->condcnt
++;
2640 free_tlist(origline
);
2641 return DIRECTIVE_FOUND
;
2645 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2646 switch(istk
->conds
->state
) {
2648 istk
->conds
->state
= COND_DONE
;
2655 case COND_ELSE_TRUE
:
2656 case COND_ELSE_FALSE
:
2657 error_precond(ERR_WARNING
|ERR_PASS1
,
2658 "`%%elif' after `%%else' ignored");
2659 istk
->conds
->state
= COND_NEVER
;
2664 * IMPORTANT: In the case of %if, we will already have
2665 * called expand_mmac_params(); however, if we're
2666 * processing an %elif we must have been in a
2667 * non-emitting mode, which would have inhibited
2668 * the normal invocation of expand_mmac_params().
2669 * Therefore, we have to do it explicitly here.
2671 j
= if_condition(expand_mmac_params(tline
->next
), i
);
2672 tline
->next
= NULL
; /* it got freed */
2673 istk
->conds
->state
=
2674 j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2677 free_tlist(origline
);
2678 return DIRECTIVE_FOUND
;
2682 error_precond(ERR_WARNING
|ERR_PASS1
,
2683 "trailing garbage after `%%else' ignored");
2685 error(ERR_FATAL
, "`%%else': no matching `%%if'");
2686 switch(istk
->conds
->state
) {
2689 istk
->conds
->state
= COND_ELSE_FALSE
;
2696 istk
->conds
->state
= COND_ELSE_TRUE
;
2699 case COND_ELSE_TRUE
:
2700 case COND_ELSE_FALSE
:
2701 error_precond(ERR_WARNING
|ERR_PASS1
,
2702 "`%%else' after `%%else' ignored.");
2703 istk
->conds
->state
= COND_NEVER
;
2706 free_tlist(origline
);
2707 return DIRECTIVE_FOUND
;
2711 error_precond(ERR_WARNING
|ERR_PASS1
,
2712 "trailing garbage after `%%endif' ignored");
2714 error(ERR_FATAL
, "`%%endif': no matching `%%if'");
2716 istk
->conds
= cond
->next
;
2719 istk
->mstk
->condcnt
--;
2720 free_tlist(origline
);
2721 return DIRECTIVE_FOUND
;
2728 error(ERR_FATAL
, "`%s': already defining a macro",
2730 return DIRECTIVE_FOUND
;
2732 defining
= nasm_malloc(sizeof(MMacro
));
2733 defining
->max_depth
=
2734 (i
== PP_RMACRO
) || (i
== PP_IRMACRO
) ? DEADMAN_LIMIT
: 0;
2735 defining
->casesense
= (i
== PP_MACRO
) || (i
== PP_RMACRO
);
2736 if (!parse_mmacro_spec(tline
, defining
, pp_directives
[i
])) {
2737 nasm_free(defining
);
2739 return DIRECTIVE_FOUND
;
2742 mmac
= (MMacro
*) hash_findix(&mmacros
, defining
->name
);
2744 if (!strcmp(mmac
->name
, defining
->name
) &&
2745 (mmac
->nparam_min
<= defining
->nparam_max
2747 && (defining
->nparam_min
<= mmac
->nparam_max
2749 error(ERR_WARNING
|ERR_PASS1
,
2750 "redefining multi-line macro `%s'", defining
->name
);
2751 return DIRECTIVE_FOUND
;
2755 free_tlist(origline
);
2756 return DIRECTIVE_FOUND
;
2760 if (! (defining
&& defining
->name
)) {
2761 error(ERR_NONFATAL
, "`%s': not defining a macro", tline
->text
);
2762 return DIRECTIVE_FOUND
;
2764 mmhead
= (MMacro
**) hash_findi_add(&mmacros
, defining
->name
);
2765 defining
->next
= *mmhead
;
2768 free_tlist(origline
);
2769 return DIRECTIVE_FOUND
;
2773 * We must search along istk->expansion until we hit a
2774 * macro-end marker for a macro with a name. Then we
2775 * bypass all lines between exitmacro and endmacro.
2777 list_for_each(l
, istk
->expansion
)
2778 if (l
->finishes
&& l
->finishes
->name
)
2783 * Remove all conditional entries relative to this
2784 * macro invocation. (safe to do in this context)
2786 for ( ; l
->finishes
->condcnt
> 0; l
->finishes
->condcnt
--) {
2788 istk
->conds
= cond
->next
;
2791 istk
->expansion
= l
;
2793 error(ERR_NONFATAL
, "`%%exitmacro' not within `%%macro' block");
2795 free_tlist(origline
);
2796 return DIRECTIVE_FOUND
;
2804 spec
.casesense
= (i
== PP_UNMACRO
);
2805 if (!parse_mmacro_spec(tline
, &spec
, pp_directives
[i
])) {
2806 return DIRECTIVE_FOUND
;
2808 mmac_p
= (MMacro
**) hash_findi(&mmacros
, spec
.name
, NULL
);
2809 while (mmac_p
&& *mmac_p
) {
2811 if (mmac
->casesense
== spec
.casesense
&&
2812 !mstrcmp(mmac
->name
, spec
.name
, spec
.casesense
) &&
2813 mmac
->nparam_min
== spec
.nparam_min
&&
2814 mmac
->nparam_max
== spec
.nparam_max
&&
2815 mmac
->plus
== spec
.plus
) {
2816 *mmac_p
= mmac
->next
;
2819 mmac_p
= &mmac
->next
;
2822 free_tlist(origline
);
2823 free_tlist(spec
.dlist
);
2824 return DIRECTIVE_FOUND
;
2828 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
2829 tline
= tline
->next
;
2831 free_tlist(origline
);
2832 error(ERR_NONFATAL
, "`%%rotate' missing rotate count");
2833 return DIRECTIVE_FOUND
;
2835 t
= expand_smacro(tline
->next
);
2837 free_tlist(origline
);
2840 tokval
.t_type
= TOKEN_INVALID
;
2842 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2845 return DIRECTIVE_FOUND
;
2847 error(ERR_WARNING
|ERR_PASS1
,
2848 "trailing garbage after expression ignored");
2849 if (!is_simple(evalresult
)) {
2850 error(ERR_NONFATAL
, "non-constant value given to `%%rotate'");
2851 return DIRECTIVE_FOUND
;
2854 while (mmac
&& !mmac
->name
) /* avoid mistaking %reps for macros */
2855 mmac
= mmac
->next_active
;
2857 error(ERR_NONFATAL
, "`%%rotate' invoked outside a macro call");
2858 } else if (mmac
->nparam
== 0) {
2860 "`%%rotate' invoked within macro without parameters");
2862 int rotate
= mmac
->rotate
+ reloc_value(evalresult
);
2864 rotate
%= (int)mmac
->nparam
;
2866 rotate
+= mmac
->nparam
;
2868 mmac
->rotate
= rotate
;
2870 return DIRECTIVE_FOUND
;
2875 tline
= tline
->next
;
2876 } while (tok_type_(tline
, TOK_WHITESPACE
));
2878 if (tok_type_(tline
, TOK_ID
) &&
2879 nasm_stricmp(tline
->text
, ".nolist") == 0) {
2882 tline
= tline
->next
;
2883 } while (tok_type_(tline
, TOK_WHITESPACE
));
2887 t
= expand_smacro(tline
);
2889 tokval
.t_type
= TOKEN_INVALID
;
2891 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2893 free_tlist(origline
);
2894 return DIRECTIVE_FOUND
;
2897 error(ERR_WARNING
|ERR_PASS1
,
2898 "trailing garbage after expression ignored");
2899 if (!is_simple(evalresult
)) {
2900 error(ERR_NONFATAL
, "non-constant value given to `%%rep'");
2901 return DIRECTIVE_FOUND
;
2903 count
= reloc_value(evalresult
);
2904 if (count
>= REP_LIMIT
) {
2905 error(ERR_NONFATAL
, "`%%rep' value exceeds limit");
2910 error(ERR_NONFATAL
, "`%%rep' expects a repeat count");
2913 free_tlist(origline
);
2915 tmp_defining
= defining
;
2916 defining
= nasm_malloc(sizeof(MMacro
));
2917 defining
->prev
= NULL
;
2918 defining
->name
= NULL
; /* flags this macro as a %rep block */
2919 defining
->casesense
= false;
2920 defining
->plus
= false;
2921 defining
->nolist
= nolist
;
2922 defining
->in_progress
= count
;
2923 defining
->max_depth
= 0;
2924 defining
->nparam_min
= defining
->nparam_max
= 0;
2925 defining
->defaults
= NULL
;
2926 defining
->dlist
= NULL
;
2927 defining
->expansion
= NULL
;
2928 defining
->next_active
= istk
->mstk
;
2929 defining
->rep_nest
= tmp_defining
;
2930 return DIRECTIVE_FOUND
;
2933 if (!defining
|| defining
->name
) {
2934 error(ERR_NONFATAL
, "`%%endrep': no matching `%%rep'");
2935 return DIRECTIVE_FOUND
;
2939 * Now we have a "macro" defined - although it has no name
2940 * and we won't be entering it in the hash tables - we must
2941 * push a macro-end marker for it on to istk->expansion.
2942 * After that, it will take care of propagating itself (a
2943 * macro-end marker line for a macro which is really a %rep
2944 * block will cause the macro to be re-expanded, complete
2945 * with another macro-end marker to ensure the process
2946 * continues) until the whole expansion is forcibly removed
2947 * from istk->expansion by a %exitrep.
2949 l
= nasm_malloc(sizeof(Line
));
2950 l
->next
= istk
->expansion
;
2951 l
->finishes
= defining
;
2953 istk
->expansion
= l
;
2955 istk
->mstk
= defining
;
2957 list
->uplevel(defining
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
2958 tmp_defining
= defining
;
2959 defining
= defining
->rep_nest
;
2960 free_tlist(origline
);
2961 return DIRECTIVE_FOUND
;
2965 * We must search along istk->expansion until we hit a
2966 * macro-end marker for a macro with no name. Then we set
2967 * its `in_progress' flag to 0.
2969 list_for_each(l
, istk
->expansion
)
2970 if (l
->finishes
&& !l
->finishes
->name
)
2974 l
->finishes
->in_progress
= 1;
2976 error(ERR_NONFATAL
, "`%%exitrep' not within `%%rep' block");
2977 free_tlist(origline
);
2978 return DIRECTIVE_FOUND
;
2984 casesense
= (i
== PP_DEFINE
|| i
== PP_XDEFINE
);
2986 tline
= tline
->next
;
2988 tline
= expand_id(tline
);
2989 if (!tline
|| (tline
->type
!= TOK_ID
&&
2990 (tline
->type
!= TOK_PREPROC_ID
||
2991 tline
->text
[1] != '$'))) {
2992 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
2994 free_tlist(origline
);
2995 return DIRECTIVE_FOUND
;
2998 ctx
= get_ctx(tline
->text
, &mname
);
3000 param_start
= tline
= tline
->next
;
3003 /* Expand the macro definition now for %xdefine and %ixdefine */
3004 if ((i
== PP_XDEFINE
) || (i
== PP_IXDEFINE
))
3005 tline
= expand_smacro(tline
);
3007 if (tok_is_(tline
, "(")) {
3009 * This macro has parameters.
3012 tline
= tline
->next
;
3016 error(ERR_NONFATAL
, "parameter identifier expected");
3017 free_tlist(origline
);
3018 return DIRECTIVE_FOUND
;
3020 if (tline
->type
!= TOK_ID
) {
3022 "`%s': parameter identifier expected",
3024 free_tlist(origline
);
3025 return DIRECTIVE_FOUND
;
3027 tline
->type
= TOK_SMAC_PARAM
+ nparam
++;
3028 tline
= tline
->next
;
3030 if (tok_is_(tline
, ",")) {
3031 tline
= tline
->next
;
3033 if (!tok_is_(tline
, ")")) {
3035 "`)' expected to terminate macro template");
3036 free_tlist(origline
);
3037 return DIRECTIVE_FOUND
;
3043 tline
= tline
->next
;
3045 if (tok_type_(tline
, TOK_WHITESPACE
))
3046 last
= tline
, tline
= tline
->next
;
3051 if (t
->type
== TOK_ID
) {
3052 list_for_each(tt
, param_start
)
3053 if (tt
->type
>= TOK_SMAC_PARAM
&&
3054 !strcmp(tt
->text
, t
->text
))
3058 t
->next
= macro_start
;
3063 * Good. We now have a macro name, a parameter count, and a
3064 * token list (in reverse order) for an expansion. We ought
3065 * to be OK just to create an SMacro, store it, and let
3066 * free_tlist have the rest of the line (which we have
3067 * carefully re-terminated after chopping off the expansion
3070 define_smacro(ctx
, mname
, casesense
, nparam
, macro_start
);
3071 free_tlist(origline
);
3072 return DIRECTIVE_FOUND
;
3075 tline
= tline
->next
;
3077 tline
= expand_id(tline
);
3078 if (!tline
|| (tline
->type
!= TOK_ID
&&
3079 (tline
->type
!= TOK_PREPROC_ID
||
3080 tline
->text
[1] != '$'))) {
3081 error(ERR_NONFATAL
, "`%%undef' expects a macro identifier");
3082 free_tlist(origline
);
3083 return DIRECTIVE_FOUND
;
3086 error(ERR_WARNING
|ERR_PASS1
,
3087 "trailing garbage after macro name ignored");
3090 /* Find the context that symbol belongs to */
3091 ctx
= get_ctx(tline
->text
, &mname
);
3092 undef_smacro(ctx
, mname
);
3093 free_tlist(origline
);
3094 return DIRECTIVE_FOUND
;
3098 casesense
= (i
== PP_DEFSTR
);
3100 tline
= tline
->next
;
3102 tline
= expand_id(tline
);
3103 if (!tline
|| (tline
->type
!= TOK_ID
&&
3104 (tline
->type
!= TOK_PREPROC_ID
||
3105 tline
->text
[1] != '$'))) {
3106 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
3108 free_tlist(origline
);
3109 return DIRECTIVE_FOUND
;
3112 ctx
= get_ctx(tline
->text
, &mname
);
3114 tline
= expand_smacro(tline
->next
);
3117 while (tok_type_(tline
, TOK_WHITESPACE
))
3118 tline
= delete_Token(tline
);
3120 p
= detoken(tline
, false);
3121 macro_start
= nasm_malloc(sizeof(*macro_start
));
3122 macro_start
->next
= NULL
;
3123 macro_start
->text
= nasm_quote(p
, strlen(p
));
3124 macro_start
->type
= TOK_STRING
;
3125 macro_start
->a
.mac
= NULL
;
3129 * We now have a macro name, an implicit parameter count of
3130 * zero, and a string token to use as an expansion. Create
3131 * and store an SMacro.
3133 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3134 free_tlist(origline
);
3135 return DIRECTIVE_FOUND
;
3139 casesense
= (i
== PP_DEFTOK
);
3141 tline
= tline
->next
;
3143 tline
= expand_id(tline
);
3144 if (!tline
|| (tline
->type
!= TOK_ID
&&
3145 (tline
->type
!= TOK_PREPROC_ID
||
3146 tline
->text
[1] != '$'))) {
3148 "`%s' expects a macro identifier as first parameter",
3150 free_tlist(origline
);
3151 return DIRECTIVE_FOUND
;
3153 ctx
= get_ctx(tline
->text
, &mname
);
3155 tline
= expand_smacro(tline
->next
);
3159 while (tok_type_(t
, TOK_WHITESPACE
))
3161 /* t should now point to the string */
3162 if (!tok_type_(t
, TOK_STRING
)) {
3164 "`%s` requires string as second parameter",
3167 free_tlist(origline
);
3168 return DIRECTIVE_FOUND
;
3172 * Convert the string to a token stream. Note that smacros
3173 * are stored with the token stream reversed, so we have to
3174 * reverse the output of tokenize().
3176 nasm_unquote_cstr(t
->text
, i
);
3177 macro_start
= reverse_tokens(tokenize(t
->text
));
3180 * We now have a macro name, an implicit parameter count of
3181 * zero, and a numeric token to use as an expansion. Create
3182 * and store an SMacro.
3184 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3186 free_tlist(origline
);
3187 return DIRECTIVE_FOUND
;
3192 StrList
*xsl
= NULL
;
3193 StrList
**xst
= &xsl
;
3197 tline
= tline
->next
;
3199 tline
= expand_id(tline
);
3200 if (!tline
|| (tline
->type
!= TOK_ID
&&
3201 (tline
->type
!= TOK_PREPROC_ID
||
3202 tline
->text
[1] != '$'))) {
3204 "`%%pathsearch' expects a macro identifier as first parameter");
3205 free_tlist(origline
);
3206 return DIRECTIVE_FOUND
;
3208 ctx
= get_ctx(tline
->text
, &mname
);
3210 tline
= expand_smacro(tline
->next
);
3214 while (tok_type_(t
, TOK_WHITESPACE
))
3217 if (!t
|| (t
->type
!= TOK_STRING
&&
3218 t
->type
!= TOK_INTERNAL_STRING
)) {
3219 error(ERR_NONFATAL
, "`%%pathsearch' expects a file name");
3221 free_tlist(origline
);
3222 return DIRECTIVE_FOUND
; /* but we did _something_ */
3225 error(ERR_WARNING
|ERR_PASS1
,
3226 "trailing garbage after `%%pathsearch' ignored");
3228 if (t
->type
!= TOK_INTERNAL_STRING
)
3229 nasm_unquote(p
, NULL
);
3231 fp
= inc_fopen(p
, &xsl
, &xst
, true);
3234 fclose(fp
); /* Don't actually care about the file */
3236 macro_start
= nasm_malloc(sizeof(*macro_start
));
3237 macro_start
->next
= NULL
;
3238 macro_start
->text
= nasm_quote(p
, strlen(p
));
3239 macro_start
->type
= TOK_STRING
;
3240 macro_start
->a
.mac
= NULL
;
3245 * We now have a macro name, an implicit parameter count of
3246 * zero, and a string token to use as an expansion. Create
3247 * and store an SMacro.
3249 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3251 free_tlist(origline
);
3252 return DIRECTIVE_FOUND
;
3258 tline
= tline
->next
;
3260 tline
= expand_id(tline
);
3261 if (!tline
|| (tline
->type
!= TOK_ID
&&
3262 (tline
->type
!= TOK_PREPROC_ID
||
3263 tline
->text
[1] != '$'))) {
3265 "`%%strlen' expects a macro identifier as first parameter");
3266 free_tlist(origline
);
3267 return DIRECTIVE_FOUND
;
3269 ctx
= get_ctx(tline
->text
, &mname
);
3271 tline
= expand_smacro(tline
->next
);
3275 while (tok_type_(t
, TOK_WHITESPACE
))
3277 /* t should now point to the string */
3278 if (!tok_type_(t
, TOK_STRING
)) {
3280 "`%%strlen` requires string as second parameter");
3282 free_tlist(origline
);
3283 return DIRECTIVE_FOUND
;
3286 macro_start
= nasm_malloc(sizeof(*macro_start
));
3287 macro_start
->next
= NULL
;
3288 make_tok_num(macro_start
, nasm_unquote(t
->text
, NULL
));
3289 macro_start
->a
.mac
= NULL
;
3292 * We now have a macro name, an implicit parameter count of
3293 * zero, and a numeric token to use as an expansion. Create
3294 * and store an SMacro.
3296 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3298 free_tlist(origline
);
3299 return DIRECTIVE_FOUND
;
3304 tline
= tline
->next
;
3306 tline
= expand_id(tline
);
3307 if (!tline
|| (tline
->type
!= TOK_ID
&&
3308 (tline
->type
!= TOK_PREPROC_ID
||
3309 tline
->text
[1] != '$'))) {
3311 "`%%strcat' expects a macro identifier as first parameter");
3312 free_tlist(origline
);
3313 return DIRECTIVE_FOUND
;
3315 ctx
= get_ctx(tline
->text
, &mname
);
3317 tline
= expand_smacro(tline
->next
);
3321 list_for_each(t
, tline
) {
3323 case TOK_WHITESPACE
:
3326 len
+= t
->a
.len
= nasm_unquote(t
->text
, NULL
);
3329 if (!strcmp(t
->text
, ",")) /* permit comma separators */
3331 /* else fall through */
3334 "non-string passed to `%%strcat' (%d)", t
->type
);
3336 free_tlist(origline
);
3337 return DIRECTIVE_FOUND
;
3341 p
= pp
= nasm_malloc(len
);
3342 list_for_each(t
, tline
) {
3343 if (t
->type
== TOK_STRING
) {
3344 memcpy(p
, t
->text
, t
->a
.len
);
3350 * We now have a macro name, an implicit parameter count of
3351 * zero, and a numeric token to use as an expansion. Create
3352 * and store an SMacro.
3354 macro_start
= new_Token(NULL
, TOK_STRING
, NULL
, 0);
3355 macro_start
->text
= nasm_quote(pp
, len
);
3357 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3359 free_tlist(origline
);
3360 return DIRECTIVE_FOUND
;
3364 int64_t start
, count
;
3369 tline
= tline
->next
;
3371 tline
= expand_id(tline
);
3372 if (!tline
|| (tline
->type
!= TOK_ID
&&
3373 (tline
->type
!= TOK_PREPROC_ID
||
3374 tline
->text
[1] != '$'))) {
3376 "`%%substr' expects a macro identifier as first parameter");
3377 free_tlist(origline
);
3378 return DIRECTIVE_FOUND
;
3380 ctx
= get_ctx(tline
->text
, &mname
);
3382 tline
= expand_smacro(tline
->next
);
3385 if (tline
) /* skip expanded id */
3387 while (tok_type_(t
, TOK_WHITESPACE
))
3390 /* t should now point to the string */
3391 if (!tok_type_(t
, TOK_STRING
)) {
3393 "`%%substr` requires string as second parameter");
3395 free_tlist(origline
);
3396 return DIRECTIVE_FOUND
;
3401 tokval
.t_type
= TOKEN_INVALID
;
3402 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3406 free_tlist(origline
);
3407 return DIRECTIVE_FOUND
;
3408 } else if (!is_simple(evalresult
)) {
3409 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3411 free_tlist(origline
);
3412 return DIRECTIVE_FOUND
;
3414 start
= evalresult
->value
- 1;
3416 while (tok_type_(tt
, TOK_WHITESPACE
))
3419 count
= 1; /* Backwards compatibility: one character */
3421 tokval
.t_type
= TOKEN_INVALID
;
3422 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3426 free_tlist(origline
);
3427 return DIRECTIVE_FOUND
;
3428 } else if (!is_simple(evalresult
)) {
3429 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3431 free_tlist(origline
);
3432 return DIRECTIVE_FOUND
;
3434 count
= evalresult
->value
;
3437 len
= nasm_unquote(t
->text
, NULL
);
3439 /* make start and count being in range */
3443 count
= len
+ count
+ 1 - start
;
3444 if (start
+ count
> (int64_t)len
)
3445 count
= len
- start
;
3446 if (!len
|| count
< 0 || start
>=(int64_t)len
)
3447 start
= -1, count
= 0; /* empty string */
3449 macro_start
= nasm_malloc(sizeof(*macro_start
));
3450 macro_start
->next
= NULL
;
3451 macro_start
->text
= nasm_quote((start
< 0) ? "" : t
->text
+ start
, count
);
3452 macro_start
->type
= TOK_STRING
;
3453 macro_start
->a
.mac
= NULL
;
3456 * We now have a macro name, an implicit parameter count of
3457 * zero, and a numeric token to use as an expansion. Create
3458 * and store an SMacro.
3460 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3462 free_tlist(origline
);
3463 return DIRECTIVE_FOUND
;
3468 casesense
= (i
== PP_ASSIGN
);
3470 tline
= tline
->next
;
3472 tline
= expand_id(tline
);
3473 if (!tline
|| (tline
->type
!= TOK_ID
&&
3474 (tline
->type
!= TOK_PREPROC_ID
||
3475 tline
->text
[1] != '$'))) {
3477 "`%%%sassign' expects a macro identifier",
3478 (i
== PP_IASSIGN
? "i" : ""));
3479 free_tlist(origline
);
3480 return DIRECTIVE_FOUND
;
3482 ctx
= get_ctx(tline
->text
, &mname
);
3484 tline
= expand_smacro(tline
->next
);
3489 tokval
.t_type
= TOKEN_INVALID
;
3491 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3494 free_tlist(origline
);
3495 return DIRECTIVE_FOUND
;
3499 error(ERR_WARNING
|ERR_PASS1
,
3500 "trailing garbage after expression ignored");
3502 if (!is_simple(evalresult
)) {
3504 "non-constant value given to `%%%sassign'",
3505 (i
== PP_IASSIGN
? "i" : ""));
3506 free_tlist(origline
);
3507 return DIRECTIVE_FOUND
;
3510 macro_start
= nasm_malloc(sizeof(*macro_start
));
3511 macro_start
->next
= NULL
;
3512 make_tok_num(macro_start
, reloc_value(evalresult
));
3513 macro_start
->a
.mac
= NULL
;
3516 * We now have a macro name, an implicit parameter count of
3517 * zero, and a numeric token to use as an expansion. Create
3518 * and store an SMacro.
3520 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3521 free_tlist(origline
);
3522 return DIRECTIVE_FOUND
;
3526 * Syntax is `%line nnn[+mmm] [filename]'
3528 tline
= tline
->next
;
3530 if (!tok_type_(tline
, TOK_NUMBER
)) {
3531 error(ERR_NONFATAL
, "`%%line' expects line number");
3532 free_tlist(origline
);
3533 return DIRECTIVE_FOUND
;
3535 k
= readnum(tline
->text
, &err
);
3537 tline
= tline
->next
;
3538 if (tok_is_(tline
, "+")) {
3539 tline
= tline
->next
;
3540 if (!tok_type_(tline
, TOK_NUMBER
)) {
3541 error(ERR_NONFATAL
, "`%%line' expects line increment");
3542 free_tlist(origline
);
3543 return DIRECTIVE_FOUND
;
3545 m
= readnum(tline
->text
, &err
);
3546 tline
= tline
->next
;
3552 nasm_free(src_set_fname(detoken(tline
, false)));
3554 free_tlist(origline
);
3555 return DIRECTIVE_FOUND
;
3559 "preprocessor directive `%s' not yet implemented",
3561 return DIRECTIVE_FOUND
;
3566 * Ensure that a macro parameter contains a condition code and
3567 * nothing else. Return the condition code index if so, or -1
3570 static int find_cc(Token
* t
)
3575 return -1; /* Probably a %+ without a space */
3578 if (t
->type
!= TOK_ID
)
3582 if (tt
&& (tt
->type
!= TOK_OTHER
|| strcmp(tt
->text
, ",")))
3585 return bsii(t
->text
, (const char **)conditions
, ARRAY_SIZE(conditions
));
3589 * This routines walks over tokens strem and hadnles tokens
3590 * pasting, if @handle_explicit passed then explicit pasting
3591 * term is handled, otherwise -- implicit pastings only.
3593 static bool paste_tokens(Token
**head
, const struct tokseq_match
*m
,
3594 size_t mnum
, bool handle_explicit
)
3596 Token
*tok
, *next
, **prev_next
, **prev_nonspace
;
3597 bool pasted
= false;
3602 * The last token before pasting. We need it
3603 * to be able to connect new handled tokens.
3604 * In other words if there were a tokens stream
3608 * and we've joined tokens B and C, the resulting
3616 if (!tok_type_(tok
, TOK_WHITESPACE
) && !tok_type_(tok
, TOK_PASTE
))
3617 prev_nonspace
= head
;
3619 prev_nonspace
= NULL
;
3621 while (tok
&& (next
= tok
->next
)) {
3623 switch (tok
->type
) {
3624 case TOK_WHITESPACE
:
3625 /* Zap redundant whitespaces */
3626 while (tok_type_(next
, TOK_WHITESPACE
))
3627 next
= delete_Token(next
);
3632 /* Explicit pasting */
3633 if (!handle_explicit
)
3635 next
= delete_Token(tok
);
3637 while (tok_type_(next
, TOK_WHITESPACE
))
3638 next
= delete_Token(next
);
3643 /* No ending token */
3645 error(ERR_FATAL
, "No rvalue found on pasting");
3647 /* Left pasting token is start of line */
3649 error(ERR_FATAL
, "No lvalue found on pasting");
3651 tok
= *prev_nonspace
;
3652 while (tok_type_(tok
, TOK_WHITESPACE
))
3653 tok
= delete_Token(tok
);
3654 len
= strlen(tok
->text
);
3655 len
+= strlen(next
->text
);
3657 p
= buf
= nasm_malloc(len
+ 1);
3658 strcpy(p
, tok
->text
);
3659 p
= strchr(p
, '\0');
3660 strcpy(p
, next
->text
);
3664 tok
= tokenize(buf
);
3667 *prev_nonspace
= tok
;
3668 while (tok
&& tok
->next
)
3671 tok
->next
= delete_Token(next
);
3673 /* Restart from pasted tokens head */
3674 tok
= *prev_nonspace
;
3678 /* implicit pasting */
3679 for (i
= 0; i
< mnum
; i
++) {
3680 if (!(PP_CONCAT_MATCH(tok
, m
[i
].mask_head
)))
3684 while (next
&& PP_CONCAT_MATCH(next
, m
[i
].mask_tail
)) {
3685 len
+= strlen(next
->text
);
3693 len
+= strlen(tok
->text
);
3694 p
= buf
= nasm_malloc(len
+ 1);
3696 while (tok
!= next
) {
3697 strcpy(p
, tok
->text
);
3698 p
= strchr(p
, '\0');
3699 tok
= delete_Token(tok
);
3702 tok
= tokenize(buf
);
3711 * Connect pasted into original stream,
3712 * ie A -> new-tokens -> B
3714 while (tok
&& tok
->next
)
3721 /* Restart from pasted tokens head */
3722 tok
= prev_next
? *prev_next
: *head
;
3728 prev_next
= &tok
->next
;
3731 !tok_type_(tok
->next
, TOK_WHITESPACE
) &&
3732 !tok_type_(tok
->next
, TOK_PASTE
))
3733 prev_nonspace
= prev_next
;
3742 * expands to a list of tokens from %{x:y}
3744 static Token
*expand_mmac_params_range(MMacro
*mac
, Token
*tline
, Token
***last
)
3746 Token
*t
= tline
, **tt
, *tm
, *head
;
3750 pos
= strchr(tline
->text
, ':');
3753 lst
= atoi(pos
+ 1);
3754 fst
= atoi(tline
->text
+ 1);
3757 * only macros params are accounted so
3758 * if someone passes %0 -- we reject such
3761 if (lst
== 0 || fst
== 0)
3764 /* the values should be sane */
3765 if ((fst
> (int)mac
->nparam
|| fst
< (-(int)mac
->nparam
)) ||
3766 (lst
> (int)mac
->nparam
|| lst
< (-(int)mac
->nparam
)))
3769 fst
= fst
< 0 ? fst
+ (int)mac
->nparam
+ 1: fst
;
3770 lst
= lst
< 0 ? lst
+ (int)mac
->nparam
+ 1: lst
;
3772 /* counted from zero */
3776 * it will be at least one token
3778 tm
= mac
->params
[(fst
+ mac
->rotate
) % mac
->nparam
];
3779 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
3780 head
= t
, tt
= &t
->next
;
3782 for (i
= fst
+ 1; i
<= lst
; i
++) {
3783 t
= new_Token(NULL
, TOK_OTHER
, ",", 0);
3784 *tt
= t
, tt
= &t
->next
;
3785 j
= (i
+ mac
->rotate
) % mac
->nparam
;
3786 tm
= mac
->params
[j
];
3787 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
3788 *tt
= t
, tt
= &t
->next
;
3791 for (i
= fst
- 1; i
>= lst
; i
--) {
3792 t
= new_Token(NULL
, TOK_OTHER
, ",", 0);
3793 *tt
= t
, tt
= &t
->next
;
3794 j
= (i
+ mac
->rotate
) % mac
->nparam
;
3795 tm
= mac
->params
[j
];
3796 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
3797 *tt
= t
, tt
= &t
->next
;
3805 error(ERR_NONFATAL
, "`%%{%s}': macro parameters out of range",
3811 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3812 * %-n) and MMacro-local identifiers (%%foo) as well as
3813 * macro indirection (%[...]) and range (%{..:..}).
3815 static Token
*expand_mmac_params(Token
* tline
)
3817 Token
*t
, *tt
, **tail
, *thead
;
3818 bool changed
= false;
3825 if (tline
->type
== TOK_PREPROC_ID
&&
3826 (((tline
->text
[1] == '+' || tline
->text
[1] == '-') && tline
->text
[2]) ||
3827 (tline
->text
[1] >= '0' && tline
->text
[1] <= '9') ||
3828 tline
->text
[1] == '%')) {
3830 int type
= 0, cc
; /* type = 0 to placate optimisers */
3837 tline
= tline
->next
;
3840 while (mac
&& !mac
->name
) /* avoid mistaking %reps for macros */
3841 mac
= mac
->next_active
;
3843 error(ERR_NONFATAL
, "`%s': not in a macro call", t
->text
);
3845 pos
= strchr(t
->text
, ':');
3847 switch (t
->text
[1]) {
3849 * We have to make a substitution of one of the
3850 * forms %1, %-1, %+1, %%foo, %0.
3854 snprintf(tmpbuf
, sizeof(tmpbuf
), "%d", mac
->nparam
);
3855 text
= nasm_strdup(tmpbuf
);
3859 snprintf(tmpbuf
, sizeof(tmpbuf
), "..@%"PRIu64
".",
3861 text
= nasm_strcat(tmpbuf
, t
->text
+ 2);
3864 n
= atoi(t
->text
+ 2) - 1;
3865 if (n
>= mac
->nparam
)
3868 if (mac
->nparam
> 1)
3869 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3870 tt
= mac
->params
[n
];
3875 "macro parameter %d is not a condition code",
3880 if (inverse_ccs
[cc
] == -1) {
3882 "condition code `%s' is not invertible",
3886 text
= nasm_strdup(conditions
[inverse_ccs
[cc
]]);
3890 n
= atoi(t
->text
+ 2) - 1;
3891 if (n
>= mac
->nparam
)
3894 if (mac
->nparam
> 1)
3895 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3896 tt
= mac
->params
[n
];
3901 "macro parameter %d is not a condition code",
3906 text
= nasm_strdup(conditions
[cc
]);
3910 n
= atoi(t
->text
+ 1) - 1;
3911 if (n
>= mac
->nparam
)
3914 if (mac
->nparam
> 1)
3915 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3916 tt
= mac
->params
[n
];
3919 for (i
= 0; i
< mac
->paramlen
[n
]; i
++) {
3920 *tail
= new_Token(NULL
, tt
->type
, tt
->text
, 0);
3921 tail
= &(*tail
)->next
;
3925 text
= NULL
; /* we've done it here */
3930 * seems we have a parameters range here
3932 Token
*head
, **last
;
3933 head
= expand_mmac_params_range(mac
, t
, &last
);
3954 } else if (tline
->type
== TOK_INDIRECT
) {
3956 tline
= tline
->next
;
3957 tt
= tokenize(t
->text
);
3958 tt
= expand_mmac_params(tt
);
3959 tt
= expand_smacro(tt
);
3962 tt
->a
.mac
= NULL
; /* Necessary? */
3970 tline
= tline
->next
;
3978 const struct tokseq_match t
[] = {
3980 PP_CONCAT_MASK(TOK_ID
) |
3981 PP_CONCAT_MASK(TOK_FLOAT
), /* head */
3982 PP_CONCAT_MASK(TOK_ID
) |
3983 PP_CONCAT_MASK(TOK_NUMBER
) |
3984 PP_CONCAT_MASK(TOK_FLOAT
) |
3985 PP_CONCAT_MASK(TOK_OTHER
) /* tail */
3988 PP_CONCAT_MASK(TOK_NUMBER
), /* head */
3989 PP_CONCAT_MASK(TOK_NUMBER
) /* tail */
3992 paste_tokens(&thead
, t
, ARRAY_SIZE(t
), false);
3999 * Expand all single-line macro calls made in the given line.
4000 * Return the expanded version of the line. The original is deemed
4001 * to be destroyed in the process. (In reality we'll just move
4002 * Tokens from input to output a lot of the time, rather than
4003 * actually bothering to destroy and replicate.)
4006 static Token
*expand_smacro(Token
* tline
)
4008 Token
*t
, *tt
, *mstart
, **tail
, *thead
;
4009 SMacro
*head
= NULL
, *m
;
4012 unsigned int nparam
, sparam
;
4014 Token
*org_tline
= tline
;
4017 int deadman
= DEADMAN_LIMIT
;
4021 * Trick: we should avoid changing the start token pointer since it can
4022 * be contained in "next" field of other token. Because of this
4023 * we allocate a copy of first token and work with it; at the end of
4024 * routine we copy it back
4027 tline
= new_Token(org_tline
->next
, org_tline
->type
,
4028 org_tline
->text
, 0);
4029 tline
->a
.mac
= org_tline
->a
.mac
;
4030 nasm_free(org_tline
->text
);
4031 org_tline
->text
= NULL
;
4034 expanded
= true; /* Always expand %+ at least once */
4040 while (tline
) { /* main token loop */
4042 error(ERR_NONFATAL
, "interminable macro recursion");
4046 if ((mname
= tline
->text
)) {
4047 /* if this token is a local macro, look in local context */
4048 if (tline
->type
== TOK_ID
) {
4049 head
= (SMacro
*)hash_findix(&smacros
, mname
);
4050 } else if (tline
->type
== TOK_PREPROC_ID
) {
4051 ctx
= get_ctx(mname
, &mname
);
4052 head
= ctx
? (SMacro
*)hash_findix(&ctx
->localmac
, mname
) : NULL
;
4057 * We've hit an identifier. As in is_mmacro below, we first
4058 * check whether the identifier is a single-line macro at
4059 * all, then think about checking for parameters if
4062 list_for_each(m
, head
)
4063 if (!mstrcmp(m
->name
, mname
, m
->casesense
))
4069 if (m
->nparam
== 0) {
4071 * Simple case: the macro is parameterless. Discard the
4072 * one token that the macro call took, and push the
4073 * expansion back on the to-do stack.
4075 if (!m
->expansion
) {
4076 if (!strcmp("__FILE__", m
->name
)) {
4079 src_get(&num
, &file
);
4080 tline
->text
= nasm_quote(file
, strlen(file
));
4081 tline
->type
= TOK_STRING
;
4085 if (!strcmp("__LINE__", m
->name
)) {
4086 nasm_free(tline
->text
);
4087 make_tok_num(tline
, src_get_linnum());
4090 if (!strcmp("__BITS__", m
->name
)) {
4091 nasm_free(tline
->text
);
4092 make_tok_num(tline
, globalbits
);
4095 tline
= delete_Token(tline
);
4100 * Complicated case: at least one macro with this name
4101 * exists and takes parameters. We must find the
4102 * parameters in the call, count them, find the SMacro
4103 * that corresponds to that form of the macro call, and
4104 * substitute for the parameters when we expand. What a
4107 /*tline = tline->next;
4108 skip_white_(tline); */
4111 while (tok_type_(t
, TOK_SMAC_END
)) {
4112 t
->a
.mac
->in_progress
= false;
4114 t
= tline
->next
= delete_Token(t
);
4117 } while (tok_type_(tline
, TOK_WHITESPACE
));
4118 if (!tok_is_(tline
, "(")) {
4120 * This macro wasn't called with parameters: ignore
4121 * the call. (Behaviour borrowed from gnu cpp.)
4130 sparam
= PARAM_DELTA
;
4131 params
= nasm_malloc(sparam
* sizeof(Token
*));
4132 params
[0] = tline
->next
;
4133 paramsize
= nasm_malloc(sparam
* sizeof(int));
4135 while (true) { /* parameter loop */
4137 * For some unusual expansions
4138 * which concatenates function call
4141 while (tok_type_(t
, TOK_SMAC_END
)) {
4142 t
->a
.mac
->in_progress
= false;
4144 t
= tline
->next
= delete_Token(t
);
4150 "macro call expects terminating `)'");
4153 if (tline
->type
== TOK_WHITESPACE
4155 if (paramsize
[nparam
])
4158 params
[nparam
] = tline
->next
;
4159 continue; /* parameter loop */
4161 if (tline
->type
== TOK_OTHER
4162 && tline
->text
[1] == 0) {
4163 char ch
= tline
->text
[0];
4164 if (ch
== ',' && !paren
&& brackets
<= 0) {
4165 if (++nparam
>= sparam
) {
4166 sparam
+= PARAM_DELTA
;
4167 params
= nasm_realloc(params
,
4168 sparam
* sizeof(Token
*));
4169 paramsize
= nasm_realloc(paramsize
,
4170 sparam
* sizeof(int));
4172 params
[nparam
] = tline
->next
;
4173 paramsize
[nparam
] = 0;
4175 continue; /* parameter loop */
4178 (brackets
> 0 || (brackets
== 0 &&
4179 !paramsize
[nparam
])))
4181 if (!(brackets
++)) {
4182 params
[nparam
] = tline
->next
;
4183 continue; /* parameter loop */
4186 if (ch
== '}' && brackets
> 0)
4187 if (--brackets
== 0) {
4189 continue; /* parameter loop */
4191 if (ch
== '(' && !brackets
)
4193 if (ch
== ')' && brackets
<= 0)
4199 error(ERR_NONFATAL
, "braces do not "
4200 "enclose all of macro parameter");
4202 paramsize
[nparam
] += white
+ 1;
4204 } /* parameter loop */
4206 while (m
&& (m
->nparam
!= nparam
||
4207 mstrcmp(m
->name
, mname
,
4211 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MNP
,
4212 "macro `%s' exists, "
4213 "but not taking %d parameters",
4214 mstart
->text
, nparam
);
4217 if (m
&& m
->in_progress
)
4219 if (!m
) { /* in progess or didn't find '(' or wrong nparam */
4221 * Design question: should we handle !tline, which
4222 * indicates missing ')' here, or expand those
4223 * macros anyway, which requires the (t) test a few
4227 nasm_free(paramsize
);
4231 * Expand the macro: we are placed on the last token of the
4232 * call, so that we can easily split the call from the
4233 * following tokens. We also start by pushing an SMAC_END
4234 * token for the cycle removal.
4241 tt
= new_Token(tline
, TOK_SMAC_END
, NULL
, 0);
4243 m
->in_progress
= true;
4245 list_for_each(t
, m
->expansion
) {
4246 if (t
->type
>= TOK_SMAC_PARAM
) {
4247 Token
*pcopy
= tline
, **ptail
= &pcopy
;
4251 ttt
= params
[t
->type
- TOK_SMAC_PARAM
];
4252 i
= paramsize
[t
->type
- TOK_SMAC_PARAM
];
4254 pt
= *ptail
= new_Token(tline
, ttt
->type
,
4260 } else if (t
->type
== TOK_PREPROC_Q
) {
4261 tt
= new_Token(tline
, TOK_ID
, mname
, 0);
4263 } else if (t
->type
== TOK_PREPROC_QQ
) {
4264 tt
= new_Token(tline
, TOK_ID
, m
->name
, 0);
4267 tt
= new_Token(tline
, t
->type
, t
->text
, 0);
4273 * Having done that, get rid of the macro call, and clean
4274 * up the parameters.
4277 nasm_free(paramsize
);
4280 continue; /* main token loop */
4285 if (tline
->type
== TOK_SMAC_END
) {
4286 tline
->a
.mac
->in_progress
= false;
4287 tline
= delete_Token(tline
);
4290 tline
= tline
->next
;
4298 * Now scan the entire line and look for successive TOK_IDs that resulted
4299 * after expansion (they can't be produced by tokenize()). The successive
4300 * TOK_IDs should be concatenated.
4301 * Also we look for %+ tokens and concatenate the tokens before and after
4302 * them (without white spaces in between).
4305 const struct tokseq_match t
[] = {
4307 PP_CONCAT_MASK(TOK_ID
) |
4308 PP_CONCAT_MASK(TOK_PREPROC_ID
), /* head */
4309 PP_CONCAT_MASK(TOK_ID
) |
4310 PP_CONCAT_MASK(TOK_PREPROC_ID
) |
4311 PP_CONCAT_MASK(TOK_NUMBER
) /* tail */
4314 if (paste_tokens(&thead
, t
, ARRAY_SIZE(t
), true)) {
4316 * If we concatenated something, *and* we had previously expanded
4317 * an actual macro, scan the lines again for macros...
4328 *org_tline
= *thead
;
4329 /* since we just gave text to org_line, don't free it */
4331 delete_Token(thead
);
4333 /* the expression expanded to empty line;
4334 we can't return NULL for some reasons
4335 we just set the line to a single WHITESPACE token. */
4336 memset(org_tline
, 0, sizeof(*org_tline
));
4337 org_tline
->text
= NULL
;
4338 org_tline
->type
= TOK_WHITESPACE
;
4347 * Similar to expand_smacro but used exclusively with macro identifiers
4348 * right before they are fetched in. The reason is that there can be
4349 * identifiers consisting of several subparts. We consider that if there
4350 * are more than one element forming the name, user wants a expansion,
4351 * otherwise it will be left as-is. Example:
4355 * the identifier %$abc will be left as-is so that the handler for %define
4356 * will suck it and define the corresponding value. Other case:
4358 * %define _%$abc cde
4360 * In this case user wants name to be expanded *before* %define starts
4361 * working, so we'll expand %$abc into something (if it has a value;
4362 * otherwise it will be left as-is) then concatenate all successive
4365 static Token
*expand_id(Token
* tline
)
4367 Token
*cur
, *oldnext
= NULL
;
4369 if (!tline
|| !tline
->next
)
4374 (cur
->next
->type
== TOK_ID
||
4375 cur
->next
->type
== TOK_PREPROC_ID
4376 || cur
->next
->type
== TOK_NUMBER
))
4379 /* If identifier consists of just one token, don't expand */
4384 oldnext
= cur
->next
; /* Detach the tail past identifier */
4385 cur
->next
= NULL
; /* so that expand_smacro stops here */
4388 tline
= expand_smacro(tline
);
4391 /* expand_smacro possibly changhed tline; re-scan for EOL */
4393 while (cur
&& cur
->next
)
4396 cur
->next
= oldnext
;
4403 * Determine whether the given line constitutes a multi-line macro
4404 * call, and return the MMacro structure called if so. Doesn't have
4405 * to check for an initial label - that's taken care of in
4406 * expand_mmacro - but must check numbers of parameters. Guaranteed
4407 * to be called with tline->type == TOK_ID, so the putative macro
4408 * name is easy to find.
4410 static MMacro
*is_mmacro(Token
* tline
, Token
*** params_array
)
4416 head
= (MMacro
*) hash_findix(&mmacros
, tline
->text
);
4419 * Efficiency: first we see if any macro exists with the given
4420 * name. If not, we can return NULL immediately. _Then_ we
4421 * count the parameters, and then we look further along the
4422 * list if necessary to find the proper MMacro.
4424 list_for_each(m
, head
)
4425 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
4431 * OK, we have a potential macro. Count and demarcate the
4434 count_mmac_params(tline
->next
, &nparam
, ¶ms
);
4437 * So we know how many parameters we've got. Find the MMacro
4438 * structure that handles this number.
4441 if (m
->nparam_min
<= nparam
4442 && (m
->plus
|| nparam
<= m
->nparam_max
)) {
4444 * This one is right. Just check if cycle removal
4445 * prohibits us using it before we actually celebrate...
4447 if (m
->in_progress
> m
->max_depth
) {
4448 if (m
->max_depth
> 0) {
4450 "reached maximum recursion depth of %i",
4457 * It's right, and we can use it. Add its default
4458 * parameters to the end of our list if necessary.
4460 if (m
->defaults
&& nparam
< m
->nparam_min
+ m
->ndefs
) {
4462 nasm_realloc(params
,
4463 ((m
->nparam_min
+ m
->ndefs
+
4464 1) * sizeof(*params
)));
4465 while (nparam
< m
->nparam_min
+ m
->ndefs
) {
4466 params
[nparam
] = m
->defaults
[nparam
- m
->nparam_min
];
4471 * If we've gone over the maximum parameter count (and
4472 * we're in Plus mode), ignore parameters beyond
4475 if (m
->plus
&& nparam
> m
->nparam_max
)
4476 nparam
= m
->nparam_max
;
4478 * Then terminate the parameter list, and leave.
4480 if (!params
) { /* need this special case */
4481 params
= nasm_malloc(sizeof(*params
));
4484 params
[nparam
] = NULL
;
4485 *params_array
= params
;
4489 * This one wasn't right: look for the next one with the
4492 list_for_each(m
, m
->next
)
4493 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
4498 * After all that, we didn't find one with the right number of
4499 * parameters. Issue a warning, and fail to expand the macro.
4501 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MNP
,
4502 "macro `%s' exists, but not taking %d parameters",
4503 tline
->text
, nparam
);
4510 * Save MMacro invocation specific fields in
4511 * preparation for a recursive macro expansion
4513 static void push_mmacro(MMacro
*m
)
4515 MMacroInvocation
*i
;
4517 i
= nasm_malloc(sizeof(MMacroInvocation
));
4519 i
->params
= m
->params
;
4520 i
->iline
= m
->iline
;
4521 i
->nparam
= m
->nparam
;
4522 i
->rotate
= m
->rotate
;
4523 i
->paramlen
= m
->paramlen
;
4524 i
->unique
= m
->unique
;
4525 i
->condcnt
= m
->condcnt
;
4531 * Restore MMacro invocation specific fields that were
4532 * saved during a previous recursive macro expansion
4534 static void pop_mmacro(MMacro
*m
)
4536 MMacroInvocation
*i
;
4541 m
->params
= i
->params
;
4542 m
->iline
= i
->iline
;
4543 m
->nparam
= i
->nparam
;
4544 m
->rotate
= i
->rotate
;
4545 m
->paramlen
= i
->paramlen
;
4546 m
->unique
= i
->unique
;
4547 m
->condcnt
= i
->condcnt
;
4554 * Expand the multi-line macro call made by the given line, if
4555 * there is one to be expanded. If there is, push the expansion on
4556 * istk->expansion and return 1. Otherwise return 0.
4558 static int expand_mmacro(Token
* tline
)
4560 Token
*startline
= tline
;
4561 Token
*label
= NULL
;
4562 int dont_prepend
= 0;
4563 Token
**params
, *t
, *tt
;
4566 int i
, nparam
, *paramlen
;
4571 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
4572 if (!tok_type_(t
, TOK_ID
) && !tok_type_(t
, TOK_PREPROC_ID
))
4574 m
= is_mmacro(t
, ¶ms
);
4580 * We have an id which isn't a macro call. We'll assume
4581 * it might be a label; we'll also check to see if a
4582 * colon follows it. Then, if there's another id after
4583 * that lot, we'll check it again for macro-hood.
4587 if (tok_type_(t
, TOK_WHITESPACE
))
4588 last
= t
, t
= t
->next
;
4589 if (tok_is_(t
, ":")) {
4591 last
= t
, t
= t
->next
;
4592 if (tok_type_(t
, TOK_WHITESPACE
))
4593 last
= t
, t
= t
->next
;
4595 if (!tok_type_(t
, TOK_ID
) || !(m
= is_mmacro(t
, ¶ms
)))
4603 * Fix up the parameters: this involves stripping leading and
4604 * trailing whitespace, then stripping braces if they are
4607 for (nparam
= 0; params
[nparam
]; nparam
++) ;
4608 paramlen
= nparam
? nasm_malloc(nparam
* sizeof(*paramlen
)) : NULL
;
4610 for (i
= 0; params
[i
]; i
++) {
4612 int comma
= (!m
->plus
|| i
< nparam
- 1);
4616 if (tok_is_(t
, "{"))
4617 t
= t
->next
, brace
= true, comma
= false;
4621 if (comma
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, ","))
4622 break; /* ... because we have hit a comma */
4623 if (comma
&& t
->type
== TOK_WHITESPACE
4624 && tok_is_(t
->next
, ","))
4625 break; /* ... or a space then a comma */
4626 if (brace
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, "}"))
4627 break; /* ... or a brace */
4634 * OK, we have a MMacro structure together with a set of
4635 * parameters. We must now go through the expansion and push
4636 * copies of each Line on to istk->expansion. Substitution of
4637 * parameter tokens and macro-local tokens doesn't get done
4638 * until the single-line macro substitution process; this is
4639 * because delaying them allows us to change the semantics
4640 * later through %rotate.
4642 * First, push an end marker on to istk->expansion, mark this
4643 * macro as in progress, and set up its invocation-specific
4646 ll
= nasm_malloc(sizeof(Line
));
4647 ll
->next
= istk
->expansion
;
4650 istk
->expansion
= ll
;
4653 * Save the previous MMacro expansion in the case of
4656 if (m
->max_depth
&& m
->in_progress
)
4664 m
->paramlen
= paramlen
;
4665 m
->unique
= unique
++;
4669 m
->next_active
= istk
->mstk
;
4672 list_for_each(l
, m
->expansion
) {
4675 ll
= nasm_malloc(sizeof(Line
));
4676 ll
->finishes
= NULL
;
4677 ll
->next
= istk
->expansion
;
4678 istk
->expansion
= ll
;
4681 list_for_each(t
, l
->first
) {
4685 tt
= *tail
= new_Token(NULL
, TOK_ID
, mname
, 0);
4687 case TOK_PREPROC_QQ
:
4688 tt
= *tail
= new_Token(NULL
, TOK_ID
, m
->name
, 0);
4690 case TOK_PREPROC_ID
:
4691 if (t
->text
[1] == '0' && t
->text
[2] == '0') {
4699 tt
= *tail
= new_Token(NULL
, x
->type
, x
->text
, 0);
4708 * If we had a label, push it on as the first line of
4709 * the macro expansion.
4712 if (dont_prepend
< 0)
4713 free_tlist(startline
);
4715 ll
= nasm_malloc(sizeof(Line
));
4716 ll
->finishes
= NULL
;
4717 ll
->next
= istk
->expansion
;
4718 istk
->expansion
= ll
;
4719 ll
->first
= startline
;
4720 if (!dont_prepend
) {
4722 label
= label
->next
;
4723 label
->next
= tt
= new_Token(NULL
, TOK_OTHER
, ":", 0);
4728 list
->uplevel(m
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
4733 /* The function that actually does the error reporting */
4734 static void verror(int severity
, const char *fmt
, va_list arg
)
4737 MMacro
*mmac
= NULL
;
4740 vsnprintf(buff
, sizeof(buff
), fmt
, arg
);
4742 /* get %macro name */
4743 if (istk
&& istk
->mstk
) {
4745 /* but %rep blocks should be skipped */
4746 while (mmac
&& !mmac
->name
)
4747 mmac
= mmac
->next_active
, delta
++;
4751 nasm_error(severity
, "(%s:%d) %s",
4752 mmac
->name
, mmac
->lineno
- delta
, buff
);
4754 nasm_error(severity
, "%s", buff
);
4758 * Since preprocessor always operate only on the line that didn't
4759 * arrived yet, we should always use ERR_OFFBY1.
4761 static void error(int severity
, const char *fmt
, ...)
4765 /* If we're in a dead branch of IF or something like it, ignore the error */
4766 if (istk
&& istk
->conds
&& !emitting(istk
->conds
->state
))
4770 verror(severity
, fmt
, arg
);
4775 * Because %else etc are evaluated in the state context
4776 * of the previous branch, errors might get lost with error():
4777 * %if 0 ... %else trailing garbage ... %endif
4778 * So %else etc should report errors with this function.
4780 static void error_precond(int severity
, const char *fmt
, ...)
4784 /* Only ignore the error if it's really in a dead branch */
4785 if (istk
&& istk
->conds
&& istk
->conds
->state
== COND_NEVER
)
4789 verror(severity
, fmt
, arg
);
4794 pp_reset(char *file
, int apass
, ListGen
* listgen
, StrList
**deplist
)
4799 istk
= nasm_malloc(sizeof(Include
));
4802 istk
->expansion
= NULL
;
4804 istk
->fp
= fopen(file
, "r");
4806 src_set_fname(nasm_strdup(file
));
4810 error(ERR_FATAL
|ERR_NOFILE
, "unable to open input file `%s'",
4813 nested_mac_count
= 0;
4814 nested_rep_count
= 0;
4817 if (tasm_compatible_mode
) {
4818 stdmacpos
= nasm_stdmac
;
4820 stdmacpos
= nasm_stdmac_after_tasm
;
4822 any_extrastdmac
= extrastdmac
&& *extrastdmac
;
4827 * 0 for dependencies, 1 for preparatory passes, 2 for final pass.
4828 * The caller, however, will also pass in 3 for preprocess-only so
4829 * we can set __PASS__ accordingly.
4831 pass
= apass
> 2 ? 2 : apass
;
4833 dephead
= deptail
= deplist
;
4835 StrList
*sl
= nasm_malloc(strlen(file
)+1+sizeof sl
->next
);
4837 strcpy(sl
->str
, file
);
4839 deptail
= &sl
->next
;
4843 * Define the __PASS__ macro. This is defined here unlike
4844 * all the other builtins, because it is special -- it varies between
4847 t
= nasm_malloc(sizeof(*t
));
4849 make_tok_num(t
, apass
);
4851 define_smacro(NULL
, "__PASS__", true, 0, t
);
4854 static char *pp_getline(void)
4861 * Fetch a tokenized line, either from the macro-expansion
4862 * buffer or from the input file.
4865 while (istk
->expansion
&& istk
->expansion
->finishes
) {
4866 Line
*l
= istk
->expansion
;
4867 if (!l
->finishes
->name
&& l
->finishes
->in_progress
> 1) {
4871 * This is a macro-end marker for a macro with no
4872 * name, which means it's not really a macro at all
4873 * but a %rep block, and the `in_progress' field is
4874 * more than 1, meaning that we still need to
4875 * repeat. (1 means the natural last repetition; 0
4876 * means termination by %exitrep.) We have
4877 * therefore expanded up to the %endrep, and must
4878 * push the whole block on to the expansion buffer
4879 * again. We don't bother to remove the macro-end
4880 * marker: we'd only have to generate another one
4883 l
->finishes
->in_progress
--;
4884 list_for_each(l
, l
->finishes
->expansion
) {
4885 Token
*t
, *tt
, **tail
;
4887 ll
= nasm_malloc(sizeof(Line
));
4888 ll
->next
= istk
->expansion
;
4889 ll
->finishes
= NULL
;
4893 list_for_each(t
, l
->first
) {
4894 if (t
->text
|| t
->type
== TOK_WHITESPACE
) {
4895 tt
= *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
4900 istk
->expansion
= ll
;
4904 * Check whether a `%rep' was started and not ended
4905 * within this macro expansion. This can happen and
4906 * should be detected. It's a fatal error because
4907 * I'm too confused to work out how to recover
4913 "defining with name in expansion");
4914 else if (istk
->mstk
->name
)
4916 "`%%rep' without `%%endrep' within"
4917 " expansion of macro `%s'",
4922 * FIXME: investigate the relationship at this point between
4923 * istk->mstk and l->finishes
4926 MMacro
*m
= istk
->mstk
;
4927 istk
->mstk
= m
->next_active
;
4930 * This was a real macro call, not a %rep, and
4931 * therefore the parameter information needs to
4936 l
->finishes
->in_progress
--;
4938 nasm_free(m
->params
);
4939 free_tlist(m
->iline
);
4940 nasm_free(m
->paramlen
);
4941 l
->finishes
->in_progress
= 0;
4946 istk
->expansion
= l
->next
;
4948 list
->downlevel(LIST_MACRO
);
4951 while (1) { /* until we get a line we can use */
4953 if (istk
->expansion
) { /* from a macro expansion */
4955 Line
*l
= istk
->expansion
;
4957 istk
->mstk
->lineno
++;
4959 istk
->expansion
= l
->next
;
4961 p
= detoken(tline
, false);
4962 list
->line(LIST_MACRO
, p
);
4967 if (line
) { /* from the current input file */
4968 line
= prepreproc(line
);
4969 tline
= tokenize(line
);
4974 * The current file has ended; work down the istk
4980 /* nasm_error can't be conditionally suppressed */
4981 nasm_error(ERR_FATAL
,
4982 "expected `%%endif' before end of file");
4984 /* only set line and file name if there's a next node */
4986 src_set_linnum(i
->lineno
);
4987 nasm_free(src_set_fname(nasm_strdup(i
->fname
)));
4990 list
->downlevel(LIST_INCLUDE
);
4994 if (istk
->expansion
&& istk
->expansion
->finishes
)
5000 * We must expand MMacro parameters and MMacro-local labels
5001 * _before_ we plunge into directive processing, to cope
5002 * with things like `%define something %1' such as STRUC
5003 * uses. Unless we're _defining_ a MMacro, in which case
5004 * those tokens should be left alone to go into the
5005 * definition; and unless we're in a non-emitting
5006 * condition, in which case we don't want to meddle with
5009 if (!defining
&& !(istk
->conds
&& !emitting(istk
->conds
->state
))
5010 && !(istk
->mstk
&& !istk
->mstk
->in_progress
)) {
5011 tline
= expand_mmac_params(tline
);
5015 * Check the line to see if it's a preprocessor directive.
5017 if (do_directive(tline
) == DIRECTIVE_FOUND
) {
5019 } else if (defining
) {
5021 * We're defining a multi-line macro. We emit nothing
5023 * shove the tokenized line on to the macro definition.
5025 Line
*l
= nasm_malloc(sizeof(Line
));
5026 l
->next
= defining
->expansion
;
5029 defining
->expansion
= l
;
5031 } else if (istk
->conds
&& !emitting(istk
->conds
->state
)) {
5033 * We're in a non-emitting branch of a condition block.
5034 * Emit nothing at all, not even a blank line: when we
5035 * emerge from the condition we'll give a line-number
5036 * directive so we keep our place correctly.
5040 } else if (istk
->mstk
&& !istk
->mstk
->in_progress
) {
5042 * We're in a %rep block which has been terminated, so
5043 * we're walking through to the %endrep without
5044 * emitting anything. Emit nothing at all, not even a
5045 * blank line: when we emerge from the %rep block we'll
5046 * give a line-number directive so we keep our place
5052 tline
= expand_smacro(tline
);
5053 if (!expand_mmacro(tline
)) {
5055 * De-tokenize the line again, and emit it.
5057 line
= detoken(tline
, true);
5061 continue; /* expand_mmacro calls free_tlist */
5069 static void pp_cleanup(int pass
)
5072 if (defining
->name
) {
5074 "end of file while still defining macro `%s'",
5077 error(ERR_NONFATAL
, "end of file while still in %%rep");
5080 free_mmacro(defining
);
5090 nasm_free(i
->fname
);
5095 nasm_free(src_set_fname(NULL
));
5100 while ((i
= ipath
)) {
5109 static void pp_include_path(char *path
)
5113 i
= nasm_malloc(sizeof(IncPath
));
5114 i
->path
= path
? nasm_strdup(path
) : NULL
;
5127 static void pp_pre_include(char *fname
)
5129 Token
*inc
, *space
, *name
;
5132 name
= new_Token(NULL
, TOK_INTERNAL_STRING
, fname
, 0);
5133 space
= new_Token(name
, TOK_WHITESPACE
, NULL
, 0);
5134 inc
= new_Token(space
, TOK_PREPROC_ID
, "%include", 0);
5136 l
= nasm_malloc(sizeof(Line
));
5143 static void pp_pre_define(char *definition
)
5149 equals
= strchr(definition
, '=');
5150 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
5151 def
= new_Token(space
, TOK_PREPROC_ID
, "%define", 0);
5154 space
->next
= tokenize(definition
);
5158 l
= nasm_malloc(sizeof(Line
));
5165 static void pp_pre_undefine(char *definition
)
5170 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
5171 def
= new_Token(space
, TOK_PREPROC_ID
, "%undef", 0);
5172 space
->next
= tokenize(definition
);
5174 l
= nasm_malloc(sizeof(Line
));
5181 static void pp_extra_stdmac(macros_t
*macros
)
5183 extrastdmac
= macros
;
5186 static void make_tok_num(Token
* tok
, int64_t val
)
5189 snprintf(numbuf
, sizeof(numbuf
), "%"PRId64
"", val
);
5190 tok
->text
= nasm_strdup(numbuf
);
5191 tok
->type
= TOK_NUMBER
;
5194 struct preproc_ops nasmpp
= {