1 /* preproc.c macro preprocessor for the Netwide Assembler
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the license given in the file "LICENSE"
6 * distributed in the NASM archive.
8 * initial version 18/iii/97 by Simon Tatham
11 /* Typical flow of text through preproc
13 * pp_getline gets tokenized lines, either
15 * from a macro expansion
19 * read_line gets raw text from stdmacpos, or predef, or current input file
20 * tokenize converts to tokens
23 * expand_mmac_params is used to expand %1 etc., unless a macro is being
24 * defined or a false conditional is being processed
25 * (%0, %1, %+1, %-1, %%foo
27 * do_directive checks for directives
29 * expand_smacro is used to expand single line macros
31 * expand_mmacro is used to expand multi-line macros
33 * detoken is used to convert the line back to text
56 typedef struct SMacro SMacro
;
57 typedef struct MMacro MMacro
;
58 typedef struct Context Context
;
59 typedef struct Token Token
;
60 typedef struct Blocks Blocks
;
61 typedef struct Line Line
;
62 typedef struct Include Include
;
63 typedef struct Cond Cond
;
64 typedef struct IncPath IncPath
;
67 * Note on the storage of both SMacro and MMacros: the hash table
68 * indexes them case-insensitively, and we then have to go through a
69 * linked list of potential case aliases (and, for MMacros, parameter
70 * ranges); this is to preserve the matching semantics of the earlier
71 * code. If the number of case aliases for a specific macro is a
72 * performance issue, you may want to reconsider your coding style.
76 * Store the definition of a single-line macro.
88 * Store the definition of a multi-line macro. This is also used to
89 * store the interiors of `%rep...%endrep' blocks, which are
90 * effectively self-re-invoking multi-line macros which simply
91 * don't have a name or bother to appear in the hash tables. %rep
92 * blocks are signified by having a NULL `name' field.
94 * In a MMacro describing a `%rep' block, the `in_progress' field
95 * isn't merely boolean, but gives the number of repeats left to
98 * The `next' field is used for storing MMacros in hash tables; the
99 * `next_active' field is for stacking them on istk entries.
101 * When a MMacro is being expanded, `params', `iline', `nparam',
102 * `paramlen', `rotate' and `unique' are local to the invocation.
107 int nparam_min
, nparam_max
;
109 bool plus
; /* is the last parameter greedy? */
110 bool nolist
; /* is this macro listing-inhibited? */
112 Token
*dlist
; /* All defaults as one list */
113 Token
**defaults
; /* Parameter default pointers */
114 int ndefs
; /* number of default parameters */
118 MMacro
*rep_nest
; /* used for nesting %rep */
119 Token
**params
; /* actual parameters */
120 Token
*iline
; /* invocation line */
121 unsigned int nparam
, rotate
;
124 int lineno
; /* Current line number on expansion */
128 * The context stack is composed of a linked list of these.
133 struct hash_table localmac
;
138 * This is the internal form which we break input lines up into.
139 * Typically stored in linked lists.
141 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
142 * necessarily used as-is, but is intended to denote the number of
143 * the substituted parameter. So in the definition
145 * %define a(x,y) ( (x) & ~(y) )
147 * the token representing `x' will have its type changed to
148 * TOK_SMAC_PARAM, but the one representing `y' will be
151 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
152 * which doesn't need quotes around it. Used in the pre-include
153 * mechanism as an alternative to trying to find a sensible type of
154 * quote to use on the filename we were passed.
157 TOK_NONE
= 0, TOK_WHITESPACE
, TOK_COMMENT
, TOK_ID
,
158 TOK_PREPROC_ID
, TOK_STRING
,
159 TOK_NUMBER
, TOK_FLOAT
, TOK_SMAC_END
, TOK_OTHER
,
161 TOK_PREPROC_Q
, TOK_PREPROC_QQ
,
162 TOK_SMAC_PARAM
, /* MUST BE LAST IN THE LIST!!! */
163 TOK_MAX
= INT_MAX
/* Keep compiler from reducing the range */
170 SMacro
*mac
; /* associated macro for TOK_SMAC_END */
171 size_t len
; /* scratch length field */
172 } a
; /* Auxiliary data */
173 enum pp_token_type type
;
177 * Multi-line macro definitions are stored as a linked list of
178 * these, which is essentially a container to allow several linked
181 * Note that in this module, linked lists are treated as stacks
182 * wherever possible. For this reason, Lines are _pushed_ on to the
183 * `expansion' field in MMacro structures, so that the linked list,
184 * if walked, would give the macro lines in reverse order; this
185 * means that we can walk the list when expanding a macro, and thus
186 * push the lines on to the `expansion' field in _istk_ in reverse
187 * order (so that when popped back off they are in the right
188 * order). It may seem cockeyed, and it relies on my design having
189 * an even number of steps in, but it works...
191 * Some of these structures, rather than being actual lines, are
192 * markers delimiting the end of the expansion of a given macro.
193 * This is for use in the cycle-tracking and %rep-handling code.
194 * Such structures have `finishes' non-NULL, and `first' NULL. All
195 * others have `finishes' NULL, but `first' may still be NULL if
205 * To handle an arbitrary level of file inclusion, we maintain a
206 * stack (ie linked list) of these things.
215 MMacro
*mstk
; /* stack of active macros/reps */
219 * Include search path. This is simply a list of strings which get
220 * prepended, in turn, to the name of an include file, in an
221 * attempt to find the file if it's not in the current directory.
229 * Conditional assembly: we maintain a separate stack of these for
230 * each level of file inclusion. (The only reason we keep the
231 * stacks separate is to ensure that a stray `%endif' in a file
232 * included from within the true branch of a `%if' won't terminate
233 * it and cause confusion: instead, rightly, it'll cause an error.)
241 * These states are for use just after %if or %elif: IF_TRUE
242 * means the condition has evaluated to truth so we are
243 * currently emitting, whereas IF_FALSE means we are not
244 * currently emitting but will start doing so if a %else comes
245 * up. In these states, all directives are admissible: %elif,
246 * %else and %endif. (And of course %if.)
248 COND_IF_TRUE
, COND_IF_FALSE
,
250 * These states come up after a %else: ELSE_TRUE means we're
251 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
252 * any %elif or %else will cause an error.
254 COND_ELSE_TRUE
, COND_ELSE_FALSE
,
256 * This state means that we're not emitting now, and also that
257 * nothing until %endif will be emitted at all. It's for use in
258 * two circumstances: (i) when we've had our moment of emission
259 * and have now started seeing %elifs, and (ii) when the
260 * condition construct in question is contained within a
261 * non-emitting branch of a larger condition construct.
265 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
268 * These defines are used as the possible return values for do_directive
270 #define NO_DIRECTIVE_FOUND 0
271 #define DIRECTIVE_FOUND 1
274 * Condition codes. Note that we use c_ prefix not C_ because C_ is
275 * used in nasm.h for the "real" condition codes. At _this_ level,
276 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
277 * ones, so we need a different enum...
279 static const char * const conditions
[] = {
280 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
281 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
282 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
285 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_CXZ
, c_E
, c_ECXZ
, c_G
, c_GE
, c_L
, c_LE
,
286 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, c_NE
, c_NG
, c_NGE
, c_NL
, c_NLE
, c_NO
,
287 c_NP
, c_NS
, c_NZ
, c_O
, c_P
, c_PE
, c_PO
, c_RCXZ
, c_S
, c_Z
,
290 static const enum pp_conds inverse_ccs
[] = {
291 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, -1, c_NE
, -1, c_NG
, c_NGE
, c_NL
, c_NLE
,
292 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_E
, c_G
, c_GE
, c_L
, c_LE
, c_O
, c_P
, c_S
,
293 c_Z
, c_NO
, c_NP
, c_PO
, c_PE
, -1, c_NS
, c_NZ
299 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
300 static int is_condition(enum preproc_token arg
)
302 return PP_IS_COND(arg
) || (arg
== PP_ELSE
) || (arg
== PP_ENDIF
);
305 /* For TASM compatibility we need to be able to recognise TASM compatible
306 * conditional compilation directives. Using the NASM pre-processor does
307 * not work, so we look for them specifically from the following list and
308 * then jam in the equivalent NASM directive into the input stream.
312 TM_ARG
, TM_ELIF
, TM_ELSE
, TM_ENDIF
, TM_IF
, TM_IFDEF
, TM_IFDIFI
,
313 TM_IFNDEF
, TM_INCLUDE
, TM_LOCAL
316 static const char * const tasm_directives
[] = {
317 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
318 "ifndef", "include", "local"
321 static int StackSize
= 4;
322 static char *StackPointer
= "ebp";
323 static int ArgOffset
= 8;
324 static int LocalOffset
= 0;
326 static Context
*cstk
;
327 static Include
*istk
;
328 static IncPath
*ipath
= NULL
;
330 static efunc _error
; /* Pointer to client-provided error reporting function */
331 static evalfunc evaluate
;
333 static int pass
; /* HACK: pass 0 = generate dependencies only */
334 static StrList
**dephead
, **deptail
; /* Dependency list */
336 static uint64_t unique
; /* unique identifier numbers */
338 static Line
*predef
= NULL
;
339 static bool do_predef
;
341 static ListGen
*list
;
344 * The current set of multi-line macros we have defined.
346 static struct hash_table mmacros
;
349 * The current set of single-line macros we have defined.
351 static struct hash_table smacros
;
354 * The multi-line macro we are currently defining, or the %rep
355 * block we are currently reading, if any.
357 static MMacro
*defining
;
359 static uint64_t nested_mac_count
;
360 static uint64_t nested_rep_count
;
363 * The number of macro parameters to allocate space for at a time.
365 #define PARAM_DELTA 16
368 * The standard macro set: defined in macros.c in the array nasm_stdmac.
369 * This gives our position in the macro set, when we're processing it.
371 static const macros_t
*stdmacpos
;
374 * The extra standard macros that come from the object format, if
377 static const macros_t
*extrastdmac
= NULL
;
378 static bool any_extrastdmac
;
381 * Tokens are allocated in blocks to improve speed
383 #define TOKEN_BLOCKSIZE 4096
384 static Token
*freeTokens
= NULL
;
390 static Blocks blocks
= { NULL
, NULL
};
393 * Forward declarations.
395 static Token
*expand_mmac_params(Token
* tline
);
396 static Token
*expand_smacro(Token
* tline
);
397 static Token
*expand_id(Token
* tline
);
398 static Context
*get_ctx(const char *name
, bool all_contexts
);
399 static void make_tok_num(Token
* tok
, int64_t val
);
400 static void error(int severity
, const char *fmt
, ...);
401 static void *new_Block(size_t size
);
402 static void delete_Blocks(void);
403 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
404 const char *text
, int txtlen
);
405 static Token
*delete_Token(Token
* t
);
408 * Macros for safe checking of token pointers, avoid *(NULL)
410 #define tok_type_(x,t) ((x) && (x)->type == (t))
411 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
412 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
413 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
415 /* Handle TASM specific directives, which do not contain a % in
416 * front of them. We do it here because I could not find any other
417 * place to do it for the moment, and it is a hack (ideally it would
418 * be nice to be able to use the NASM pre-processor to do it).
420 static char *check_tasm_directive(char *line
)
422 int32_t i
, j
, k
, m
, len
;
423 char *p
= line
, *oldline
, oldchar
;
425 /* Skip whitespace */
426 while (nasm_isspace(*p
) && *p
!= 0)
429 /* Binary search for the directive name */
431 j
= elements(tasm_directives
);
433 while (!nasm_isspace(p
[len
]) && p
[len
] != 0)
440 m
= nasm_stricmp(p
, tasm_directives
[k
]);
442 /* We have found a directive, so jam a % in front of it
443 * so that NASM will then recognise it as one if it's own.
448 line
= nasm_malloc(len
+ 2);
450 if (k
== TM_IFDIFI
) {
451 /* NASM does not recognise IFDIFI, so we convert it to
452 * %ifdef BOGUS. This is not used in NASM comaptible
453 * code, but does need to parse for the TASM macro
456 strcpy(line
+ 1, "ifdef BOGUS");
458 memcpy(line
+ 1, p
, len
+ 1);
473 * The pre-preprocessing stage... This function translates line
474 * number indications as they emerge from GNU cpp (`# lineno "file"
475 * flags') into NASM preprocessor line number indications (`%line
478 static char *prepreproc(char *line
)
481 char *fname
, *oldline
;
483 if (line
[0] == '#' && line
[1] == ' ') {
486 lineno
= atoi(fname
);
487 fname
+= strspn(fname
, "0123456789 ");
490 fnlen
= strcspn(fname
, "\"");
491 line
= nasm_malloc(20 + fnlen
);
492 snprintf(line
, 20 + fnlen
, "%%line %d %.*s", lineno
, fnlen
, fname
);
495 if (tasm_compatible_mode
)
496 return check_tasm_directive(line
);
501 * Free a linked list of tokens.
503 static void free_tlist(Token
* list
)
506 list
= delete_Token(list
);
511 * Free a linked list of lines.
513 static void free_llist(Line
* list
)
519 free_tlist(l
->first
);
527 static void free_mmacro(MMacro
* m
)
530 free_tlist(m
->dlist
);
531 nasm_free(m
->defaults
);
532 free_llist(m
->expansion
);
537 * Free all currently defined macros, and free the hash tables
539 static void free_smacro_table(struct hash_table
*smt
)
543 struct hash_tbl_node
*it
= NULL
;
545 while ((s
= hash_iterate(smt
, &it
, &key
)) != NULL
) {
546 nasm_free((void *)key
);
548 SMacro
*ns
= s
->next
;
550 free_tlist(s
->expansion
);
558 static void free_mmacro_table(struct hash_table
*mmt
)
562 struct hash_tbl_node
*it
= NULL
;
565 while ((m
= hash_iterate(mmt
, &it
, &key
)) != NULL
) {
566 nasm_free((void *)key
);
568 MMacro
*nm
= m
->next
;
576 static void free_macros(void)
578 free_smacro_table(&smacros
);
579 free_mmacro_table(&mmacros
);
583 * Initialize the hash tables
585 static void init_macros(void)
587 hash_init(&smacros
, HASH_LARGE
);
588 hash_init(&mmacros
, HASH_LARGE
);
592 * Pop the context stack.
594 static void ctx_pop(void)
599 free_smacro_table(&c
->localmac
);
605 * Search for a key in the hash index; adding it if necessary
606 * (in which case we initialize the data pointer to NULL.)
609 hash_findi_add(struct hash_table
*hash
, const char *str
)
611 struct hash_insert hi
;
615 r
= hash_findi(hash
, str
, &hi
);
619 strx
= nasm_strdup(str
); /* Use a more efficient allocator here? */
620 return hash_add(&hi
, strx
, NULL
);
624 * Like hash_findi, but returns the data element rather than a pointer
625 * to it. Used only when not adding a new element, hence no third
629 hash_findix(struct hash_table
*hash
, const char *str
)
633 p
= hash_findi(hash
, str
, NULL
);
634 return p
? *p
: NULL
;
637 #define BUF_DELTA 512
639 * Read a line from the top file in istk, handling multiple CR/LFs
640 * at the end of the line read, and handling spurious ^Zs. Will
641 * return lines from the standard macro set if this has not already
644 static char *read_line(void)
646 char *buffer
, *p
, *q
;
647 int bufsize
, continued_count
;
651 const unsigned char *p
= stdmacpos
;
656 len
+= pp_directives_len
[c
-0x80]+1;
660 ret
= nasm_malloc(len
+1);
662 while ((c
= *stdmacpos
++)) {
664 memcpy(q
, pp_directives
[c
-0x80], pp_directives_len
[c
-0x80]);
665 q
+= pp_directives_len
[c
-0x80];
675 /* This was the last of the standard macro chain... */
677 if (any_extrastdmac
) {
678 stdmacpos
= extrastdmac
;
679 any_extrastdmac
= false;
680 } else if (do_predef
) {
682 Token
*head
, **tail
, *t
;
685 * Nasty hack: here we push the contents of
686 * `predef' on to the top-level expansion stack,
687 * since this is the most convenient way to
688 * implement the pre-include and pre-define
691 for (pd
= predef
; pd
; pd
= pd
->next
) {
694 for (t
= pd
->first
; t
; t
= t
->next
) {
695 *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
696 tail
= &(*tail
)->next
;
698 l
= nasm_malloc(sizeof(Line
));
699 l
->next
= istk
->expansion
;
711 buffer
= nasm_malloc(BUF_DELTA
);
715 q
= fgets(p
, bufsize
- (p
- buffer
), istk
->fp
);
719 if (p
> buffer
&& p
[-1] == '\n') {
720 /* Convert backslash-CRLF line continuation sequences into
721 nothing at all (for DOS and Windows) */
722 if (((p
- 2) > buffer
) && (p
[-3] == '\\') && (p
[-2] == '\r')) {
727 /* Also convert backslash-LF line continuation sequences into
728 nothing at all (for Unix) */
729 else if (((p
- 1) > buffer
) && (p
[-2] == '\\')) {
737 if (p
- buffer
> bufsize
- 10) {
738 int32_t offset
= p
- buffer
;
739 bufsize
+= BUF_DELTA
;
740 buffer
= nasm_realloc(buffer
, bufsize
);
741 p
= buffer
+ offset
; /* prevent stale-pointer problems */
745 if (!q
&& p
== buffer
) {
750 src_set_linnum(src_get_linnum() + istk
->lineinc
+
751 (continued_count
* istk
->lineinc
));
754 * Play safe: remove CRs as well as LFs, if any of either are
755 * present at the end of the line.
757 while (--p
>= buffer
&& (*p
== '\n' || *p
== '\r'))
761 * Handle spurious ^Z, which may be inserted into source files
762 * by some file transfer utilities.
764 buffer
[strcspn(buffer
, "\032")] = '\0';
766 list
->line(LIST_READ
, buffer
);
772 * Tokenize a line of text. This is a very simple process since we
773 * don't need to parse the value out of e.g. numeric tokens: we
774 * simply split one string into many.
776 static Token
*tokenize(char *line
)
779 enum pp_token_type type
;
781 Token
*t
, **tail
= &list
;
787 if (nasm_isdigit(*p
) ||
788 ((*p
== '-' || *p
== '+') && nasm_isdigit(p
[1])) ||
789 ((*p
== '+') && (nasm_isspace(p
[1]) || !p
[1]))) {
793 while (nasm_isdigit(*p
));
794 type
= TOK_PREPROC_ID
;
795 } else if (*p
== '{') {
797 while (*p
&& *p
!= '}') {
804 type
= TOK_PREPROC_ID
;
805 } else if (*p
== '?') {
806 type
= TOK_PREPROC_Q
; /* %? */
809 type
= TOK_PREPROC_QQ
; /* %?? */
812 } else if (isidchar(*p
) ||
813 ((*p
== '!' || *p
== '%' || *p
== '$') &&
818 while (isidchar(*p
));
819 type
= TOK_PREPROC_ID
;
825 } else if (isidstart(*p
) || (*p
== '$' && isidstart(p
[1]))) {
828 while (*p
&& isidchar(*p
))
830 } else if (*p
== '\'' || *p
== '"' || *p
== '`') {
835 p
= nasm_skip_string(p
);
840 error(ERR_WARNING
, "unterminated string");
841 /* Handling unterminated strings by UNV */
844 } else if (isnumstart(*p
)) {
846 bool is_float
= false;
862 if (!is_hex
&& (c
== 'e' || c
== 'E')) {
864 if (*p
== '+' || *p
== '-') {
865 /* e can only be followed by +/- if it is either a
866 prefixed hex number or a floating-point number */
870 } else if (c
== 'H' || c
== 'h' || c
== 'X' || c
== 'x') {
872 } else if (c
== 'P' || c
== 'p') {
874 if (*p
== '+' || *p
== '-')
876 } else if (isnumchar(c
) || c
== '_')
879 /* we need to deal with consequences of the legacy
880 parser, like "1.nolist" being two tokens
881 (TOK_NUMBER, TOK_ID) here; at least give it
882 a shot for now. In the future, we probably need
883 a flex-based scanner with proper pattern matching
884 to do it as well as it can be done. Nothing in
885 the world is going to help the person who wants
886 0x123.p16 interpreted as two tokens, though. */
891 if (nasm_isdigit(*r
) || (is_hex
&& nasm_isxdigit(*r
)) ||
892 (!is_hex
&& (*r
== 'e' || *r
== 'E')) ||
893 (*r
== 'p' || *r
== 'P')) {
897 break; /* Terminate the token */
901 p
--; /* Point to first character beyond number */
903 if (has_e
&& !is_hex
) {
904 /* 1e13 is floating-point, but 1e13h is not */
908 type
= is_float
? TOK_FLOAT
: TOK_NUMBER
;
909 } else if (nasm_isspace(*p
)) {
910 type
= TOK_WHITESPACE
;
912 while (*p
&& nasm_isspace(*p
))
915 * Whitespace just before end-of-line is discarded by
916 * pretending it's a comment; whitespace just before a
917 * comment gets lumped into the comment.
919 if (!*p
|| *p
== ';') {
924 } else if (*p
== ';') {
930 * Anything else is an operator of some kind. We check
931 * for all the double-character operators (>>, <<, //,
932 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
933 * else is a single-character operator.
936 if ((p
[0] == '>' && p
[1] == '>') ||
937 (p
[0] == '<' && p
[1] == '<') ||
938 (p
[0] == '/' && p
[1] == '/') ||
939 (p
[0] == '<' && p
[1] == '=') ||
940 (p
[0] == '>' && p
[1] == '=') ||
941 (p
[0] == '=' && p
[1] == '=') ||
942 (p
[0] == '!' && p
[1] == '=') ||
943 (p
[0] == '<' && p
[1] == '>') ||
944 (p
[0] == '&' && p
[1] == '&') ||
945 (p
[0] == '|' && p
[1] == '|') ||
946 (p
[0] == '^' && p
[1] == '^')) {
952 /* Handling unterminated string by UNV */
955 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
956 t->text[p-line] = *line;
960 if (type
!= TOK_COMMENT
) {
961 *tail
= t
= new_Token(NULL
, type
, line
, p
- line
);
970 * this function allocates a new managed block of memory and
971 * returns a pointer to the block. The managed blocks are
972 * deleted only all at once by the delete_Blocks function.
974 static void *new_Block(size_t size
)
978 /* first, get to the end of the linked list */
981 /* now allocate the requested chunk */
982 b
->chunk
= nasm_malloc(size
);
984 /* now allocate a new block for the next request */
985 b
->next
= nasm_malloc(sizeof(Blocks
));
986 /* and initialize the contents of the new block */
987 b
->next
->next
= NULL
;
988 b
->next
->chunk
= NULL
;
993 * this function deletes all managed blocks of memory
995 static void delete_Blocks(void)
997 Blocks
*a
, *b
= &blocks
;
1000 * keep in mind that the first block, pointed to by blocks
1001 * is a static and not dynamically allocated, so we don't
1006 nasm_free(b
->chunk
);
1015 * this function creates a new Token and passes a pointer to it
1016 * back to the caller. It sets the type and text elements, and
1017 * also the a.mac and next elements to NULL.
1019 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
1020 const char *text
, int txtlen
)
1025 if (freeTokens
== NULL
) {
1026 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
1027 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
1028 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
1029 freeTokens
[i
].next
= NULL
;
1032 freeTokens
= t
->next
;
1036 if (type
== TOK_WHITESPACE
|| text
== NULL
) {
1040 txtlen
= strlen(text
);
1041 t
->text
= nasm_malloc(txtlen
+1);
1042 memcpy(t
->text
, text
, txtlen
);
1043 t
->text
[txtlen
] = '\0';
1048 static Token
*delete_Token(Token
* t
)
1050 Token
*next
= t
->next
;
1052 t
->next
= freeTokens
;
1058 * Convert a line of tokens back into text.
1059 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1060 * will be transformed into ..@ctxnum.xxx
1062 static char *detoken(Token
* tlist
, bool expand_locals
)
1070 for (t
= tlist
; t
; t
= t
->next
) {
1071 if (t
->type
== TOK_PREPROC_ID
&& t
->text
[1] == '!') {
1072 char *p
= getenv(t
->text
+ 2);
1075 t
->text
= nasm_strdup(p
);
1079 /* Expand local macros here and not during preprocessing */
1080 if (expand_locals
&&
1081 t
->type
== TOK_PREPROC_ID
&& t
->text
&&
1082 t
->text
[0] == '%' && t
->text
[1] == '$') {
1083 Context
*ctx
= get_ctx(t
->text
, false);
1086 char *p
, *q
= t
->text
+ 2;
1088 q
+= strspn(q
, "$");
1089 snprintf(buffer
, sizeof(buffer
), "..@%"PRIu32
".", ctx
->number
);
1090 p
= nasm_strcat(buffer
, q
);
1095 if (t
->type
== TOK_WHITESPACE
) {
1097 } else if (t
->text
) {
1098 len
+= strlen(t
->text
);
1101 p
= line
= nasm_malloc(len
+ 1);
1102 for (t
= tlist
; t
; t
= t
->next
) {
1103 if (t
->type
== TOK_WHITESPACE
) {
1105 } else if (t
->text
) {
1116 * A scanner, suitable for use by the expression evaluator, which
1117 * operates on a line of Tokens. Expects a pointer to a pointer to
1118 * the first token in the line to be passed in as its private_data
1121 * FIX: This really needs to be unified with stdscan.
1123 static int ppscan(void *private_data
, struct tokenval
*tokval
)
1125 Token
**tlineptr
= private_data
;
1127 char ourcopy
[MAX_KEYWORD
+1], *p
, *r
, *s
;
1131 *tlineptr
= tline
? tline
->next
: NULL
;
1133 while (tline
&& (tline
->type
== TOK_WHITESPACE
||
1134 tline
->type
== TOK_COMMENT
));
1137 return tokval
->t_type
= TOKEN_EOS
;
1139 tokval
->t_charptr
= tline
->text
;
1141 if (tline
->text
[0] == '$' && !tline
->text
[1])
1142 return tokval
->t_type
= TOKEN_HERE
;
1143 if (tline
->text
[0] == '$' && tline
->text
[1] == '$' && !tline
->text
[2])
1144 return tokval
->t_type
= TOKEN_BASE
;
1146 if (tline
->type
== TOK_ID
) {
1147 p
= tokval
->t_charptr
= tline
->text
;
1149 tokval
->t_charptr
++;
1150 return tokval
->t_type
= TOKEN_ID
;
1153 for (r
= p
, s
= ourcopy
; *r
; r
++) {
1154 if (r
>= p
+MAX_KEYWORD
)
1155 return tokval
->t_type
= TOKEN_ID
; /* Not a keyword */
1156 *s
++ = nasm_tolower(*r
);
1159 /* right, so we have an identifier sitting in temp storage. now,
1160 * is it actually a register or instruction name, or what? */
1161 return nasm_token_hash(ourcopy
, tokval
);
1164 if (tline
->type
== TOK_NUMBER
) {
1166 tokval
->t_integer
= readnum(tline
->text
, &rn_error
);
1167 tokval
->t_charptr
= tline
->text
;
1169 return tokval
->t_type
= TOKEN_ERRNUM
;
1171 return tokval
->t_type
= TOKEN_NUM
;
1174 if (tline
->type
== TOK_FLOAT
) {
1175 return tokval
->t_type
= TOKEN_FLOAT
;
1178 if (tline
->type
== TOK_STRING
) {
1181 bq
= tline
->text
[0];
1182 tokval
->t_charptr
= tline
->text
;
1183 tokval
->t_inttwo
= nasm_unquote(tline
->text
, &ep
);
1185 if (ep
[0] != bq
|| ep
[1] != '\0')
1186 return tokval
->t_type
= TOKEN_ERRSTR
;
1188 return tokval
->t_type
= TOKEN_STR
;
1191 if (tline
->type
== TOK_OTHER
) {
1192 if (!strcmp(tline
->text
, "<<"))
1193 return tokval
->t_type
= TOKEN_SHL
;
1194 if (!strcmp(tline
->text
, ">>"))
1195 return tokval
->t_type
= TOKEN_SHR
;
1196 if (!strcmp(tline
->text
, "//"))
1197 return tokval
->t_type
= TOKEN_SDIV
;
1198 if (!strcmp(tline
->text
, "%%"))
1199 return tokval
->t_type
= TOKEN_SMOD
;
1200 if (!strcmp(tline
->text
, "=="))
1201 return tokval
->t_type
= TOKEN_EQ
;
1202 if (!strcmp(tline
->text
, "<>"))
1203 return tokval
->t_type
= TOKEN_NE
;
1204 if (!strcmp(tline
->text
, "!="))
1205 return tokval
->t_type
= TOKEN_NE
;
1206 if (!strcmp(tline
->text
, "<="))
1207 return tokval
->t_type
= TOKEN_LE
;
1208 if (!strcmp(tline
->text
, ">="))
1209 return tokval
->t_type
= TOKEN_GE
;
1210 if (!strcmp(tline
->text
, "&&"))
1211 return tokval
->t_type
= TOKEN_DBL_AND
;
1212 if (!strcmp(tline
->text
, "^^"))
1213 return tokval
->t_type
= TOKEN_DBL_XOR
;
1214 if (!strcmp(tline
->text
, "||"))
1215 return tokval
->t_type
= TOKEN_DBL_OR
;
1219 * We have no other options: just return the first character of
1222 return tokval
->t_type
= tline
->text
[0];
1226 * Compare a string to the name of an existing macro; this is a
1227 * simple wrapper which calls either strcmp or nasm_stricmp
1228 * depending on the value of the `casesense' parameter.
1230 static int mstrcmp(const char *p
, const char *q
, bool casesense
)
1232 return casesense
? strcmp(p
, q
) : nasm_stricmp(p
, q
);
1236 * Compare a string to the name of an existing macro; this is a
1237 * simple wrapper which calls either strcmp or nasm_stricmp
1238 * depending on the value of the `casesense' parameter.
1240 static int mmemcmp(const char *p
, const char *q
, size_t l
, bool casesense
)
1242 return casesense
? memcmp(p
, q
, l
) : nasm_memicmp(p
, q
, l
);
1246 * Return the Context structure associated with a %$ token. Return
1247 * NULL, having _already_ reported an error condition, if the
1248 * context stack isn't deep enough for the supplied number of $
1250 * If all_contexts == true, contexts that enclose current are
1251 * also scanned for such smacro, until it is found; if not -
1252 * only the context that directly results from the number of $'s
1253 * in variable's name.
1255 static Context
*get_ctx(const char *name
, bool all_contexts
)
1261 if (!name
|| name
[0] != '%' || name
[1] != '$')
1265 error(ERR_NONFATAL
, "`%s': context stack is empty", name
);
1269 for (i
= strspn(name
+ 2, "$"), ctx
= cstk
; (i
> 0) && ctx
; i
--) {
1271 /* i--; Lino - 02/25/02 */
1274 error(ERR_NONFATAL
, "`%s': context stack is only"
1275 " %d level%s deep", name
, i
- 1, (i
== 2 ? "" : "s"));
1282 /* Search for this smacro in found context */
1283 m
= hash_findix(&ctx
->localmac
, name
);
1285 if (!mstrcmp(m
->name
, name
, m
->casesense
))
1296 * Check to see if a file is already in a string list
1298 static bool in_list(const StrList
*list
, const char *str
)
1301 if (!strcmp(list
->str
, str
))
1309 * Open an include file. This routine must always return a valid
1310 * file pointer if it returns - it's responsible for throwing an
1311 * ERR_FATAL and bombing out completely if not. It should also try
1312 * the include path one by one until it finds the file or reaches
1313 * the end of the path.
1315 static FILE *inc_fopen(const char *file
, StrList
**dhead
, StrList
***dtail
,
1320 IncPath
*ip
= ipath
;
1321 int len
= strlen(file
);
1322 size_t prefix_len
= 0;
1326 sl
= nasm_malloc(prefix_len
+len
+1+sizeof sl
->next
);
1327 memcpy(sl
->str
, prefix
, prefix_len
);
1328 memcpy(sl
->str
+prefix_len
, file
, len
+1);
1329 fp
= fopen(sl
->str
, "r");
1330 if (fp
&& dhead
&& !in_list(*dhead
, sl
->str
)) {
1348 prefix_len
= strlen(prefix
);
1350 /* -MG given and file not found */
1351 if (dhead
&& !in_list(*dhead
, file
)) {
1352 sl
= nasm_malloc(len
+1+sizeof sl
->next
);
1354 strcpy(sl
->str
, file
);
1362 error(ERR_FATAL
, "unable to open include file `%s'", file
);
1363 return NULL
; /* never reached - placate compilers */
1367 * Determine if we should warn on defining a single-line macro of
1368 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1369 * return true if _any_ single-line macro of that name is defined.
1370 * Otherwise, will return true if a single-line macro with either
1371 * `nparam' or no parameters is defined.
1373 * If a macro with precisely the right number of parameters is
1374 * defined, or nparam is -1, the address of the definition structure
1375 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1376 * is NULL, no action will be taken regarding its contents, and no
1379 * Note that this is also called with nparam zero to resolve
1382 * If you already know which context macro belongs to, you can pass
1383 * the context pointer as first parameter; if you won't but name begins
1384 * with %$ the context will be automatically computed. If all_contexts
1385 * is true, macro will be searched in outer contexts as well.
1388 smacro_defined(Context
* ctx
, const char *name
, int nparam
, SMacro
** defn
,
1391 struct hash_table
*smtbl
;
1395 smtbl
= &ctx
->localmac
;
1396 } else if (name
[0] == '%' && name
[1] == '$') {
1398 ctx
= get_ctx(name
, false);
1400 return false; /* got to return _something_ */
1401 smtbl
= &ctx
->localmac
;
1405 m
= (SMacro
*) hash_findix(smtbl
, name
);
1408 if (!mstrcmp(m
->name
, name
, m
->casesense
&& nocase
) &&
1409 (nparam
<= 0 || m
->nparam
== 0 || nparam
== (int) m
->nparam
)) {
1411 if (nparam
== (int) m
->nparam
|| nparam
== -1)
1425 * Count and mark off the parameters in a multi-line macro call.
1426 * This is called both from within the multi-line macro expansion
1427 * code, and also to mark off the default parameters when provided
1428 * in a %macro definition line.
1430 static void count_mmac_params(Token
* t
, int *nparam
, Token
*** params
)
1432 int paramsize
, brace
;
1434 *nparam
= paramsize
= 0;
1437 if (*nparam
>= paramsize
) {
1438 paramsize
+= PARAM_DELTA
;
1439 *params
= nasm_realloc(*params
, sizeof(**params
) * paramsize
);
1443 if (tok_is_(t
, "{"))
1445 (*params
)[(*nparam
)++] = t
;
1446 while (tok_isnt_(t
, brace
? "}" : ","))
1448 if (t
) { /* got a comma/brace */
1452 * Now we've found the closing brace, look further
1456 if (tok_isnt_(t
, ",")) {
1458 "braces do not enclose all of macro parameter");
1459 while (tok_isnt_(t
, ","))
1463 t
= t
->next
; /* eat the comma */
1470 * Determine whether one of the various `if' conditions is true or
1473 * We must free the tline we get passed.
1475 static bool if_condition(Token
* tline
, enum preproc_token ct
)
1477 enum pp_conditional i
= PP_COND(ct
);
1479 Token
*t
, *tt
, **tptr
, *origline
;
1480 struct tokenval tokval
;
1482 enum pp_token_type needtype
;
1488 j
= false; /* have we matched yet? */
1489 while (cstk
&& tline
) {
1491 if (!tline
|| tline
->type
!= TOK_ID
) {
1493 "`%s' expects context identifiers", pp_directives
[ct
]);
1494 free_tlist(origline
);
1497 if (cstk
->name
&& !nasm_stricmp(tline
->text
, cstk
->name
))
1499 tline
= tline
->next
;
1504 j
= false; /* have we matched yet? */
1507 if (!tline
|| (tline
->type
!= TOK_ID
&&
1508 (tline
->type
!= TOK_PREPROC_ID
||
1509 tline
->text
[1] != '$'))) {
1511 "`%s' expects macro identifiers", pp_directives
[ct
]);
1514 if (smacro_defined(NULL
, tline
->text
, 0, NULL
, true))
1516 tline
= tline
->next
;
1522 tline
= expand_smacro(tline
);
1524 while (tok_isnt_(tt
, ","))
1528 "`%s' expects two comma-separated arguments",
1533 j
= true; /* assume equality unless proved not */
1534 while ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) && tt
) {
1535 if (tt
->type
== TOK_OTHER
&& !strcmp(tt
->text
, ",")) {
1536 error(ERR_NONFATAL
, "`%s': more than one comma on line",
1540 if (t
->type
== TOK_WHITESPACE
) {
1544 if (tt
->type
== TOK_WHITESPACE
) {
1548 if (tt
->type
!= t
->type
) {
1549 j
= false; /* found mismatching tokens */
1552 /* When comparing strings, need to unquote them first */
1553 if (t
->type
== TOK_STRING
) {
1554 size_t l1
= nasm_unquote(t
->text
, NULL
);
1555 size_t l2
= nasm_unquote(tt
->text
, NULL
);
1561 if (mmemcmp(t
->text
, tt
->text
, l1
, i
== PPC_IFIDN
)) {
1565 } else if (mstrcmp(tt
->text
, t
->text
, i
== PPC_IFIDN
) != 0) {
1566 j
= false; /* found mismatching tokens */
1573 if ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) || tt
)
1574 j
= false; /* trailing gunk on one end or other */
1580 MMacro searching
, *mmac
;
1582 tline
= tline
->next
;
1584 tline
= expand_id(tline
);
1585 if (!tok_type_(tline
, TOK_ID
)) {
1587 "`%s' expects a macro name", pp_directives
[ct
]);
1590 searching
.name
= nasm_strdup(tline
->text
);
1591 searching
.casesense
= true;
1592 searching
.plus
= false;
1593 searching
.nolist
= false;
1594 searching
.in_progress
= 0;
1595 searching
.rep_nest
= NULL
;
1596 searching
.nparam_min
= 0;
1597 searching
.nparam_max
= INT_MAX
;
1598 tline
= expand_smacro(tline
->next
);
1601 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
1603 "`%s' expects a parameter count or nothing",
1606 searching
.nparam_min
= searching
.nparam_max
=
1607 readnum(tline
->text
, &j
);
1610 "unable to parse parameter count `%s'",
1613 if (tline
&& tok_is_(tline
->next
, "-")) {
1614 tline
= tline
->next
->next
;
1615 if (tok_is_(tline
, "*"))
1616 searching
.nparam_max
= INT_MAX
;
1617 else if (!tok_type_(tline
, TOK_NUMBER
))
1619 "`%s' expects a parameter count after `-'",
1622 searching
.nparam_max
= readnum(tline
->text
, &j
);
1625 "unable to parse parameter count `%s'",
1627 if (searching
.nparam_min
> searching
.nparam_max
)
1629 "minimum parameter count exceeds maximum");
1632 if (tline
&& tok_is_(tline
->next
, "+")) {
1633 tline
= tline
->next
;
1634 searching
.plus
= true;
1636 mmac
= (MMacro
*) hash_findix(&mmacros
, searching
.name
);
1638 if (!strcmp(mmac
->name
, searching
.name
) &&
1639 (mmac
->nparam_min
<= searching
.nparam_max
1641 && (searching
.nparam_min
<= mmac
->nparam_max
1648 nasm_free(searching
.name
);
1657 needtype
= TOK_NUMBER
;
1660 needtype
= TOK_STRING
;
1664 t
= tline
= expand_smacro(tline
);
1666 while (tok_type_(t
, TOK_WHITESPACE
) ||
1667 (needtype
== TOK_NUMBER
&&
1668 tok_type_(t
, TOK_OTHER
) &&
1669 (t
->text
[0] == '-' || t
->text
[0] == '+') &&
1673 j
= tok_type_(t
, needtype
);
1677 t
= tline
= expand_smacro(tline
);
1678 while (tok_type_(t
, TOK_WHITESPACE
))
1683 t
= t
->next
; /* Skip the actual token */
1684 while (tok_type_(t
, TOK_WHITESPACE
))
1686 j
= !t
; /* Should be nothing left */
1691 t
= tline
= expand_smacro(tline
);
1692 while (tok_type_(t
, TOK_WHITESPACE
))
1695 j
= !t
; /* Should be empty */
1699 t
= tline
= expand_smacro(tline
);
1701 tokval
.t_type
= TOKEN_INVALID
;
1702 evalresult
= evaluate(ppscan
, tptr
, &tokval
,
1703 NULL
, pass
| CRITICAL
, error
, NULL
);
1708 "trailing garbage after expression ignored");
1709 if (!is_simple(evalresult
)) {
1711 "non-constant value given to `%s'", pp_directives
[ct
]);
1714 j
= reloc_value(evalresult
) != 0;
1719 "preprocessor directive `%s' not yet implemented",
1724 free_tlist(origline
);
1725 return j
^ PP_NEGATIVE(ct
);
1728 free_tlist(origline
);
1733 * Common code for defining an smacro
1735 static bool define_smacro(Context
*ctx
, char *mname
, bool casesense
,
1736 int nparam
, Token
*expansion
)
1738 SMacro
*smac
, **smhead
;
1739 struct hash_table
*smtbl
;
1741 if (smacro_defined(ctx
, mname
, nparam
, &smac
, casesense
)) {
1744 "single-line macro `%s' defined both with and"
1745 " without parameters", mname
);
1747 /* Some instances of the old code considered this a failure,
1748 some others didn't. What is the right thing to do here? */
1749 free_tlist(expansion
);
1750 return false; /* Failure */
1753 * We're redefining, so we have to take over an
1754 * existing SMacro structure. This means freeing
1755 * what was already in it.
1757 nasm_free(smac
->name
);
1758 free_tlist(smac
->expansion
);
1761 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1762 smhead
= (SMacro
**) hash_findi_add(smtbl
, mname
);
1763 smac
= nasm_malloc(sizeof(SMacro
));
1764 smac
->next
= *smhead
;
1767 smac
->name
= nasm_strdup(mname
);
1768 smac
->casesense
= casesense
;
1769 smac
->nparam
= nparam
;
1770 smac
->expansion
= expansion
;
1771 smac
->in_progress
= false;
1772 return true; /* Success */
1776 * Undefine an smacro
1778 static void undef_smacro(Context
*ctx
, const char *mname
)
1780 SMacro
**smhead
, *s
, **sp
;
1781 struct hash_table
*smtbl
;
1783 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1784 smhead
= (SMacro
**)hash_findi(smtbl
, mname
, NULL
);
1788 * We now have a macro name... go hunt for it.
1791 while ((s
= *sp
) != NULL
) {
1792 if (!mstrcmp(s
->name
, mname
, s
->casesense
)) {
1795 free_tlist(s
->expansion
);
1805 * Decode a size directive
1807 static int parse_size(const char *str
) {
1808 static const char *size_names
[] =
1809 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
1810 static const int sizes
[] =
1811 { 0, 1, 4, 16, 8, 10, 2, 32 };
1813 return sizes
[bsii(str
, size_names
, elements(size_names
))+1];
1817 * find and process preprocessor directive in passed line
1818 * Find out if a line contains a preprocessor directive, and deal
1821 * If a directive _is_ found, it is the responsibility of this routine
1822 * (and not the caller) to free_tlist() the line.
1824 * @param tline a pointer to the current tokeninzed line linked list
1825 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
1828 static int do_directive(Token
* tline
)
1830 enum preproc_token i
;
1838 char *p
, *pp
, *mname
;
1842 MMacro
*mmac
, **mmhead
;
1843 Token
*t
, *tt
, *param_start
, *macro_start
, *last
, **tptr
, *origline
;
1845 struct tokenval tokval
;
1847 MMacro
*tmp_defining
; /* Used when manipulating rep_nest */
1854 if (!tline
|| !tok_type_(tline
, TOK_PREPROC_ID
) ||
1855 (tline
->text
[1] == '%' || tline
->text
[1] == '$'
1856 || tline
->text
[1] == '!'))
1857 return NO_DIRECTIVE_FOUND
;
1859 i
= pp_token_hash(tline
->text
);
1862 * If we're in a non-emitting branch of a condition construct,
1863 * or walking to the end of an already terminated %rep block,
1864 * we should ignore all directives except for condition
1867 if (((istk
->conds
&& !emitting(istk
->conds
->state
)) ||
1868 (istk
->mstk
&& !istk
->mstk
->in_progress
)) && !is_condition(i
)) {
1869 return NO_DIRECTIVE_FOUND
;
1873 * If we're defining a macro or reading a %rep block, we should
1874 * ignore all directives except for %macro/%imacro (which
1875 * generate an error), %endm/%endmacro, and (only if we're in a
1876 * %rep block) %endrep. If we're in a %rep block, another %rep
1877 * causes an error, so should be let through.
1879 if (defining
&& i
!= PP_MACRO
&& i
!= PP_IMACRO
&&
1880 i
!= PP_ENDMACRO
&& i
!= PP_ENDM
&&
1881 (defining
->name
|| (i
!= PP_ENDREP
&& i
!= PP_REP
))) {
1882 return NO_DIRECTIVE_FOUND
;
1886 if (i
== PP_MACRO
|| i
== PP_IMACRO
) {
1888 return NO_DIRECTIVE_FOUND
;
1889 } else if (nested_mac_count
> 0) {
1890 if (i
== PP_ENDMACRO
) {
1892 return NO_DIRECTIVE_FOUND
;
1895 if (!defining
->name
) {
1898 return NO_DIRECTIVE_FOUND
;
1899 } else if (nested_rep_count
> 0) {
1900 if (i
== PP_ENDREP
) {
1902 return NO_DIRECTIVE_FOUND
;
1910 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
1912 return NO_DIRECTIVE_FOUND
; /* didn't get it */
1915 /* Directive to tell NASM what the default stack size is. The
1916 * default is for a 16-bit stack, and this can be overriden with
1918 * the following form:
1920 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1922 tline
= tline
->next
;
1923 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1924 tline
= tline
->next
;
1925 if (!tline
|| tline
->type
!= TOK_ID
) {
1926 error(ERR_NONFATAL
, "`%%stacksize' missing size parameter");
1927 free_tlist(origline
);
1928 return DIRECTIVE_FOUND
;
1930 if (nasm_stricmp(tline
->text
, "flat") == 0) {
1931 /* All subsequent ARG directives are for a 32-bit stack */
1933 StackPointer
= "ebp";
1936 } else if (nasm_stricmp(tline
->text
, "flat64") == 0) {
1937 /* All subsequent ARG directives are for a 64-bit stack */
1939 StackPointer
= "rbp";
1942 } else if (nasm_stricmp(tline
->text
, "large") == 0) {
1943 /* All subsequent ARG directives are for a 16-bit stack,
1944 * far function call.
1947 StackPointer
= "bp";
1950 } else if (nasm_stricmp(tline
->text
, "small") == 0) {
1951 /* All subsequent ARG directives are for a 16-bit stack,
1952 * far function call. We don't support near functions.
1955 StackPointer
= "bp";
1959 error(ERR_NONFATAL
, "`%%stacksize' invalid size type");
1960 free_tlist(origline
);
1961 return DIRECTIVE_FOUND
;
1963 free_tlist(origline
);
1964 return DIRECTIVE_FOUND
;
1967 /* TASM like ARG directive to define arguments to functions, in
1968 * the following form:
1970 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1974 char *arg
, directive
[256];
1975 int size
= StackSize
;
1977 /* Find the argument name */
1978 tline
= tline
->next
;
1979 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1980 tline
= tline
->next
;
1981 if (!tline
|| tline
->type
!= TOK_ID
) {
1982 error(ERR_NONFATAL
, "`%%arg' missing argument parameter");
1983 free_tlist(origline
);
1984 return DIRECTIVE_FOUND
;
1988 /* Find the argument size type */
1989 tline
= tline
->next
;
1990 if (!tline
|| tline
->type
!= TOK_OTHER
1991 || tline
->text
[0] != ':') {
1993 "Syntax error processing `%%arg' directive");
1994 free_tlist(origline
);
1995 return DIRECTIVE_FOUND
;
1997 tline
= tline
->next
;
1998 if (!tline
|| tline
->type
!= TOK_ID
) {
1999 error(ERR_NONFATAL
, "`%%arg' missing size type parameter");
2000 free_tlist(origline
);
2001 return DIRECTIVE_FOUND
;
2004 /* Allow macro expansion of type parameter */
2005 tt
= tokenize(tline
->text
);
2006 tt
= expand_smacro(tt
);
2007 size
= parse_size(tt
->text
);
2010 "Invalid size type for `%%arg' missing directive");
2012 free_tlist(origline
);
2013 return DIRECTIVE_FOUND
;
2017 /* Round up to even stack slots */
2018 size
= (size
+StackSize
-1) & ~(StackSize
-1);
2020 /* Now define the macro for the argument */
2021 snprintf(directive
, sizeof(directive
), "%%define %s (%s+%d)",
2022 arg
, StackPointer
, offset
);
2023 do_directive(tokenize(directive
));
2026 /* Move to the next argument in the list */
2027 tline
= tline
->next
;
2028 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2029 tline
= tline
->next
;
2030 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2032 free_tlist(origline
);
2033 return DIRECTIVE_FOUND
;
2036 /* TASM like LOCAL directive to define local variables for a
2037 * function, in the following form:
2039 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2041 * The '= LocalSize' at the end is ignored by NASM, but is
2042 * required by TASM to define the local parameter size (and used
2043 * by the TASM macro package).
2045 offset
= LocalOffset
;
2047 char *local
, directive
[256];
2048 int size
= StackSize
;
2050 /* Find the argument name */
2051 tline
= tline
->next
;
2052 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2053 tline
= tline
->next
;
2054 if (!tline
|| tline
->type
!= TOK_ID
) {
2056 "`%%local' missing argument parameter");
2057 free_tlist(origline
);
2058 return DIRECTIVE_FOUND
;
2060 local
= tline
->text
;
2062 /* Find the argument size type */
2063 tline
= tline
->next
;
2064 if (!tline
|| tline
->type
!= TOK_OTHER
2065 || tline
->text
[0] != ':') {
2067 "Syntax error processing `%%local' directive");
2068 free_tlist(origline
);
2069 return DIRECTIVE_FOUND
;
2071 tline
= tline
->next
;
2072 if (!tline
|| tline
->type
!= TOK_ID
) {
2074 "`%%local' missing size type parameter");
2075 free_tlist(origline
);
2076 return DIRECTIVE_FOUND
;
2079 /* Allow macro expansion of type parameter */
2080 tt
= tokenize(tline
->text
);
2081 tt
= expand_smacro(tt
);
2082 size
= parse_size(tt
->text
);
2085 "Invalid size type for `%%local' missing directive");
2087 free_tlist(origline
);
2088 return DIRECTIVE_FOUND
;
2092 /* Round up to even stack slots */
2093 size
= (size
+StackSize
-1) & ~(StackSize
-1);
2095 offset
+= size
; /* Negative offset, increment before */
2097 /* Now define the macro for the argument */
2098 snprintf(directive
, sizeof(directive
), "%%define %s (%s-%d)",
2099 local
, StackPointer
, offset
);
2100 do_directive(tokenize(directive
));
2102 /* Now define the assign to setup the enter_c macro correctly */
2103 snprintf(directive
, sizeof(directive
),
2104 "%%assign %%$localsize %%$localsize+%d", size
);
2105 do_directive(tokenize(directive
));
2107 /* Move to the next argument in the list */
2108 tline
= tline
->next
;
2109 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2110 tline
= tline
->next
;
2111 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2112 LocalOffset
= offset
;
2113 free_tlist(origline
);
2114 return DIRECTIVE_FOUND
;
2118 error(ERR_WARNING
, "trailing garbage after `%%clear' ignored");
2121 free_tlist(origline
);
2122 return DIRECTIVE_FOUND
;
2125 t
= tline
->next
= expand_smacro(tline
->next
);
2127 if (!t
|| (t
->type
!= TOK_STRING
&&
2128 t
->type
!= TOK_INTERNAL_STRING
)) {
2129 error(ERR_NONFATAL
, "`%%depend' expects a file name");
2130 free_tlist(origline
);
2131 return DIRECTIVE_FOUND
; /* but we did _something_ */
2135 "trailing garbage after `%%depend' ignored");
2137 if (t
->type
!= TOK_INTERNAL_STRING
)
2138 nasm_unquote(p
, NULL
);
2139 if (dephead
&& !in_list(*dephead
, p
)) {
2140 StrList
*sl
= nasm_malloc(strlen(p
)+1+sizeof sl
->next
);
2144 deptail
= &sl
->next
;
2146 free_tlist(origline
);
2147 return DIRECTIVE_FOUND
;
2150 t
= tline
->next
= expand_smacro(tline
->next
);
2153 if (!t
|| (t
->type
!= TOK_STRING
&&
2154 t
->type
!= TOK_INTERNAL_STRING
)) {
2155 error(ERR_NONFATAL
, "`%%include' expects a file name");
2156 free_tlist(origline
);
2157 return DIRECTIVE_FOUND
; /* but we did _something_ */
2161 "trailing garbage after `%%include' ignored");
2163 if (t
->type
!= TOK_INTERNAL_STRING
)
2164 nasm_unquote(p
, NULL
);
2165 inc
= nasm_malloc(sizeof(Include
));
2168 inc
->fp
= inc_fopen(p
, dephead
, &deptail
, pass
== 0);
2170 /* -MG given but file not found */
2173 inc
->fname
= src_set_fname(nasm_strdup(p
));
2174 inc
->lineno
= src_set_linnum(0);
2176 inc
->expansion
= NULL
;
2179 list
->uplevel(LIST_INCLUDE
);
2181 free_tlist(origline
);
2182 return DIRECTIVE_FOUND
;
2186 static const macros_t
*use_pkg
;
2187 const char *pkg_macro
;
2189 t
= tline
->next
= expand_smacro(tline
->next
);
2192 if (!t
|| (t
->type
!= TOK_STRING
&&
2193 t
->type
!= TOK_INTERNAL_STRING
&&
2194 t
->type
!= TOK_ID
)) {
2195 error(ERR_NONFATAL
, "`%%use' expects a package name");
2196 free_tlist(origline
);
2197 return DIRECTIVE_FOUND
; /* but we did _something_ */
2201 "trailing garbage after `%%use' ignored");
2202 if (t
->type
== TOK_STRING
)
2203 nasm_unquote(t
->text
, NULL
);
2204 use_pkg
= nasm_stdmac_find_package(t
->text
);
2206 error(ERR_NONFATAL
, "unknown `%%use' package: %s", t
->text
);
2207 /* The first string will be <%define>__USE_*__ */
2208 pkg_macro
= (char *)use_pkg
+ 1;
2209 if (!smacro_defined(NULL
, pkg_macro
, 0, NULL
, true)) {
2210 /* Not already included, go ahead and include it */
2211 stdmacpos
= use_pkg
;
2213 free_tlist(origline
);
2214 return DIRECTIVE_FOUND
;
2217 tline
= tline
->next
;
2219 tline
= expand_id(tline
);
2221 if (!tok_type_(tline
, TOK_ID
)) {
2222 error(ERR_NONFATAL
, "`%%push' expects a context identifier");
2223 free_tlist(origline
);
2224 return DIRECTIVE_FOUND
; /* but we did _something_ */
2227 error(ERR_WARNING
, "trailing garbage after `%%push' ignored");
2228 p
= nasm_strdup(tline
->text
);
2230 p
= NULL
; /* Anonymous context */
2232 ctx
= nasm_malloc(sizeof(Context
));
2234 hash_init(&ctx
->localmac
, HASH_SMALL
);
2236 ctx
->number
= unique
++;
2238 free_tlist(origline
);
2242 tline
= tline
->next
;
2244 tline
= expand_id(tline
);
2246 if (!tok_type_(tline
, TOK_ID
)) {
2247 error(ERR_NONFATAL
, "`%%repl' expects a context identifier");
2248 free_tlist(origline
);
2249 return DIRECTIVE_FOUND
; /* but we did _something_ */
2252 error(ERR_WARNING
, "trailing garbage after `%%repl' ignored");
2253 p
= nasm_strdup(tline
->text
);
2258 error(ERR_NONFATAL
, "`%%repl': context stack is empty");
2260 nasm_free(cstk
->name
);
2263 free_tlist(origline
);
2268 error(ERR_WARNING
, "trailing garbage after `%%pop' ignored");
2270 error(ERR_NONFATAL
, "`%%pop': context stack is already empty");
2273 free_tlist(origline
);
2279 int severity
= PP_ERROR
? ERR_NONFATAL
|ERR_NO_SEVERITY
:
2280 ERR_WARNING
|ERR_NO_SEVERITY
;
2282 tline
->next
= expand_smacro(tline
->next
);
2283 tline
= tline
->next
;
2285 t
= tline
? tline
->next
: NULL
;
2287 if (tok_type_(tline
, TOK_STRING
) && !t
) {
2288 /* The line contains only a quoted string */
2290 nasm_unquote(p
, NULL
);
2291 error(severity
, "%s: %s", pp_directives
[i
], p
);
2293 /* Not a quoted string, or more than a quoted string */
2294 p
= detoken(tline
, false);
2295 error(severity
, "%s: %s", pp_directives
[i
], p
);
2298 free_tlist(origline
);
2303 if (istk
->conds
&& !emitting(istk
->conds
->state
))
2306 j
= if_condition(tline
->next
, i
);
2307 tline
->next
= NULL
; /* it got freed */
2308 j
= j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2310 cond
= nasm_malloc(sizeof(Cond
));
2311 cond
->next
= istk
->conds
;
2314 free_tlist(origline
);
2315 return DIRECTIVE_FOUND
;
2319 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2320 if (emitting(istk
->conds
->state
)
2321 || istk
->conds
->state
== COND_NEVER
)
2322 istk
->conds
->state
= COND_NEVER
;
2325 * IMPORTANT: In the case of %if, we will already have
2326 * called expand_mmac_params(); however, if we're
2327 * processing an %elif we must have been in a
2328 * non-emitting mode, which would have inhibited
2329 * the normal invocation of expand_mmac_params(). Therefore,
2330 * we have to do it explicitly here.
2332 j
= if_condition(expand_mmac_params(tline
->next
), i
);
2333 tline
->next
= NULL
; /* it got freed */
2334 istk
->conds
->state
=
2335 j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2337 free_tlist(origline
);
2338 return DIRECTIVE_FOUND
;
2342 error(ERR_WARNING
, "trailing garbage after `%%else' ignored");
2344 error(ERR_FATAL
, "`%%else': no matching `%%if'");
2345 if (emitting(istk
->conds
->state
)
2346 || istk
->conds
->state
== COND_NEVER
)
2347 istk
->conds
->state
= COND_ELSE_FALSE
;
2349 istk
->conds
->state
= COND_ELSE_TRUE
;
2350 free_tlist(origline
);
2351 return DIRECTIVE_FOUND
;
2355 error(ERR_WARNING
, "trailing garbage after `%%endif' ignored");
2357 error(ERR_FATAL
, "`%%endif': no matching `%%if'");
2359 istk
->conds
= cond
->next
;
2361 free_tlist(origline
);
2362 return DIRECTIVE_FOUND
;
2368 "`%%%smacro': already defining a macro",
2369 (i
== PP_IMACRO
? "i" : ""));
2370 tline
= tline
->next
;
2372 tline
= expand_id(tline
);
2373 if (!tok_type_(tline
, TOK_ID
)) {
2375 "`%%%smacro' expects a macro name",
2376 (i
== PP_IMACRO
? "i" : ""));
2377 return DIRECTIVE_FOUND
;
2379 defining
= nasm_malloc(sizeof(MMacro
));
2380 defining
->name
= nasm_strdup(tline
->text
);
2381 defining
->casesense
= (i
== PP_MACRO
);
2382 defining
->plus
= false;
2383 defining
->nolist
= false;
2384 defining
->in_progress
= 0;
2385 defining
->rep_nest
= NULL
;
2386 tline
= expand_smacro(tline
->next
);
2388 if (!tok_type_(tline
, TOK_NUMBER
)) {
2390 "`%%%smacro' expects a parameter count",
2391 (i
== PP_IMACRO
? "i" : ""));
2392 defining
->nparam_min
= defining
->nparam_max
= 0;
2394 defining
->nparam_min
= defining
->nparam_max
=
2395 readnum(tline
->text
, &err
);
2398 "unable to parse parameter count `%s'", tline
->text
);
2400 if (tline
&& tok_is_(tline
->next
, "-")) {
2401 tline
= tline
->next
->next
;
2402 if (tok_is_(tline
, "*"))
2403 defining
->nparam_max
= INT_MAX
;
2404 else if (!tok_type_(tline
, TOK_NUMBER
))
2406 "`%%%smacro' expects a parameter count after `-'",
2407 (i
== PP_IMACRO
? "i" : ""));
2409 defining
->nparam_max
= readnum(tline
->text
, &err
);
2412 "unable to parse parameter count `%s'",
2414 if (defining
->nparam_min
> defining
->nparam_max
)
2416 "minimum parameter count exceeds maximum");
2419 if (tline
&& tok_is_(tline
->next
, "+")) {
2420 tline
= tline
->next
;
2421 defining
->plus
= true;
2423 if (tline
&& tok_type_(tline
->next
, TOK_ID
) &&
2424 !nasm_stricmp(tline
->next
->text
, ".nolist")) {
2425 tline
= tline
->next
;
2426 defining
->nolist
= true;
2428 mmac
= (MMacro
*) hash_findix(&mmacros
, defining
->name
);
2430 if (!strcmp(mmac
->name
, defining
->name
) &&
2431 (mmac
->nparam_min
<= defining
->nparam_max
2433 && (defining
->nparam_min
<= mmac
->nparam_max
2436 "redefining multi-line macro `%s'", defining
->name
);
2442 * Handle default parameters.
2444 if (tline
&& tline
->next
) {
2445 defining
->dlist
= tline
->next
;
2447 count_mmac_params(defining
->dlist
, &defining
->ndefs
,
2448 &defining
->defaults
);
2450 defining
->dlist
= NULL
;
2451 defining
->defaults
= NULL
;
2453 defining
->expansion
= NULL
;
2454 free_tlist(origline
);
2455 return DIRECTIVE_FOUND
;
2460 error(ERR_NONFATAL
, "`%s': not defining a macro", tline
->text
);
2461 return DIRECTIVE_FOUND
;
2463 mmhead
= (MMacro
**) hash_findi_add(&mmacros
, defining
->name
);
2464 defining
->next
= *mmhead
;
2467 free_tlist(origline
);
2468 return DIRECTIVE_FOUND
;
2471 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
2472 tline
= tline
->next
;
2473 if (tline
->next
== NULL
) {
2474 free_tlist(origline
);
2475 error(ERR_NONFATAL
, "`%%rotate' missing rotate count");
2476 return DIRECTIVE_FOUND
;
2478 t
= expand_smacro(tline
->next
);
2480 free_tlist(origline
);
2483 tokval
.t_type
= TOKEN_INVALID
;
2485 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2488 return DIRECTIVE_FOUND
;
2491 "trailing garbage after expression ignored");
2492 if (!is_simple(evalresult
)) {
2493 error(ERR_NONFATAL
, "non-constant value given to `%%rotate'");
2494 return DIRECTIVE_FOUND
;
2497 while (mmac
&& !mmac
->name
) /* avoid mistaking %reps for macros */
2498 mmac
= mmac
->next_active
;
2500 error(ERR_NONFATAL
, "`%%rotate' invoked outside a macro call");
2501 } else if (mmac
->nparam
== 0) {
2503 "`%%rotate' invoked within macro without parameters");
2505 int rotate
= mmac
->rotate
+ reloc_value(evalresult
);
2507 rotate
%= (int)mmac
->nparam
;
2509 rotate
+= mmac
->nparam
;
2511 mmac
->rotate
= rotate
;
2513 return DIRECTIVE_FOUND
;
2518 tline
= tline
->next
;
2519 } while (tok_type_(tline
, TOK_WHITESPACE
));
2521 if (tok_type_(tline
, TOK_ID
) &&
2522 nasm_stricmp(tline
->text
, ".nolist") == 0) {
2525 tline
= tline
->next
;
2526 } while (tok_type_(tline
, TOK_WHITESPACE
));
2530 t
= expand_smacro(tline
);
2532 tokval
.t_type
= TOKEN_INVALID
;
2534 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2536 free_tlist(origline
);
2537 return DIRECTIVE_FOUND
;
2541 "trailing garbage after expression ignored");
2542 if (!is_simple(evalresult
)) {
2543 error(ERR_NONFATAL
, "non-constant value given to `%%rep'");
2544 return DIRECTIVE_FOUND
;
2546 count
= reloc_value(evalresult
) + 1;
2548 error(ERR_NONFATAL
, "`%%rep' expects a repeat count");
2551 free_tlist(origline
);
2553 tmp_defining
= defining
;
2554 defining
= nasm_malloc(sizeof(MMacro
));
2555 defining
->name
= NULL
; /* flags this macro as a %rep block */
2556 defining
->casesense
= false;
2557 defining
->plus
= false;
2558 defining
->nolist
= nolist
;
2559 defining
->in_progress
= count
;
2560 defining
->nparam_min
= defining
->nparam_max
= 0;
2561 defining
->defaults
= NULL
;
2562 defining
->dlist
= NULL
;
2563 defining
->expansion
= NULL
;
2564 defining
->next_active
= istk
->mstk
;
2565 defining
->rep_nest
= tmp_defining
;
2566 return DIRECTIVE_FOUND
;
2569 if (!defining
|| defining
->name
) {
2570 error(ERR_NONFATAL
, "`%%endrep': no matching `%%rep'");
2571 return DIRECTIVE_FOUND
;
2575 * Now we have a "macro" defined - although it has no name
2576 * and we won't be entering it in the hash tables - we must
2577 * push a macro-end marker for it on to istk->expansion.
2578 * After that, it will take care of propagating itself (a
2579 * macro-end marker line for a macro which is really a %rep
2580 * block will cause the macro to be re-expanded, complete
2581 * with another macro-end marker to ensure the process
2582 * continues) until the whole expansion is forcibly removed
2583 * from istk->expansion by a %exitrep.
2585 l
= nasm_malloc(sizeof(Line
));
2586 l
->next
= istk
->expansion
;
2587 l
->finishes
= defining
;
2589 istk
->expansion
= l
;
2591 istk
->mstk
= defining
;
2593 list
->uplevel(defining
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
2594 tmp_defining
= defining
;
2595 defining
= defining
->rep_nest
;
2596 free_tlist(origline
);
2597 return DIRECTIVE_FOUND
;
2601 * We must search along istk->expansion until we hit a
2602 * macro-end marker for a macro with no name. Then we set
2603 * its `in_progress' flag to 0.
2605 for (l
= istk
->expansion
; l
; l
= l
->next
)
2606 if (l
->finishes
&& !l
->finishes
->name
)
2610 l
->finishes
->in_progress
= 1;
2612 error(ERR_NONFATAL
, "`%%exitrep' not within `%%rep' block");
2613 free_tlist(origline
);
2614 return DIRECTIVE_FOUND
;
2620 casesense
= (i
== PP_DEFINE
|| i
== PP_XDEFINE
);
2622 tline
= tline
->next
;
2624 tline
= expand_id(tline
);
2625 if (!tline
|| (tline
->type
!= TOK_ID
&&
2626 (tline
->type
!= TOK_PREPROC_ID
||
2627 tline
->text
[1] != '$'))) {
2628 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
2630 free_tlist(origline
);
2631 return DIRECTIVE_FOUND
;
2634 ctx
= get_ctx(tline
->text
, false);
2636 mname
= tline
->text
;
2638 param_start
= tline
= tline
->next
;
2641 /* Expand the macro definition now for %xdefine and %ixdefine */
2642 if ((i
== PP_XDEFINE
) || (i
== PP_IXDEFINE
))
2643 tline
= expand_smacro(tline
);
2645 if (tok_is_(tline
, "(")) {
2647 * This macro has parameters.
2650 tline
= tline
->next
;
2654 error(ERR_NONFATAL
, "parameter identifier expected");
2655 free_tlist(origline
);
2656 return DIRECTIVE_FOUND
;
2658 if (tline
->type
!= TOK_ID
) {
2660 "`%s': parameter identifier expected",
2662 free_tlist(origline
);
2663 return DIRECTIVE_FOUND
;
2665 tline
->type
= TOK_SMAC_PARAM
+ nparam
++;
2666 tline
= tline
->next
;
2668 if (tok_is_(tline
, ",")) {
2669 tline
= tline
->next
;
2672 if (!tok_is_(tline
, ")")) {
2674 "`)' expected to terminate macro template");
2675 free_tlist(origline
);
2676 return DIRECTIVE_FOUND
;
2681 tline
= tline
->next
;
2683 if (tok_type_(tline
, TOK_WHITESPACE
))
2684 last
= tline
, tline
= tline
->next
;
2689 if (t
->type
== TOK_ID
) {
2690 for (tt
= param_start
; tt
; tt
= tt
->next
)
2691 if (tt
->type
>= TOK_SMAC_PARAM
&&
2692 !strcmp(tt
->text
, t
->text
))
2696 t
->next
= macro_start
;
2701 * Good. We now have a macro name, a parameter count, and a
2702 * token list (in reverse order) for an expansion. We ought
2703 * to be OK just to create an SMacro, store it, and let
2704 * free_tlist have the rest of the line (which we have
2705 * carefully re-terminated after chopping off the expansion
2708 define_smacro(ctx
, mname
, casesense
, nparam
, macro_start
);
2709 free_tlist(origline
);
2710 return DIRECTIVE_FOUND
;
2713 tline
= tline
->next
;
2715 tline
= expand_id(tline
);
2716 if (!tline
|| (tline
->type
!= TOK_ID
&&
2717 (tline
->type
!= TOK_PREPROC_ID
||
2718 tline
->text
[1] != '$'))) {
2719 error(ERR_NONFATAL
, "`%%undef' expects a macro identifier");
2720 free_tlist(origline
);
2721 return DIRECTIVE_FOUND
;
2725 "trailing garbage after macro name ignored");
2728 /* Find the context that symbol belongs to */
2729 ctx
= get_ctx(tline
->text
, false);
2730 undef_smacro(ctx
, tline
->text
);
2731 free_tlist(origline
);
2732 return DIRECTIVE_FOUND
;
2736 casesense
= (i
== PP_DEFSTR
);
2738 tline
= tline
->next
;
2740 tline
= expand_id(tline
);
2741 if (!tline
|| (tline
->type
!= TOK_ID
&&
2742 (tline
->type
!= TOK_PREPROC_ID
||
2743 tline
->text
[1] != '$'))) {
2744 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
2746 free_tlist(origline
);
2747 return DIRECTIVE_FOUND
;
2750 ctx
= get_ctx(tline
->text
, false);
2752 mname
= tline
->text
;
2754 tline
= expand_smacro(tline
->next
);
2757 while (tok_type_(tline
, TOK_WHITESPACE
))
2758 tline
= delete_Token(tline
);
2760 p
= detoken(tline
, false);
2761 macro_start
= nasm_malloc(sizeof(*macro_start
));
2762 macro_start
->next
= NULL
;
2763 macro_start
->text
= nasm_quote(p
, strlen(p
));
2764 macro_start
->type
= TOK_STRING
;
2765 macro_start
->a
.mac
= NULL
;
2769 * We now have a macro name, an implicit parameter count of
2770 * zero, and a string token to use as an expansion. Create
2771 * and store an SMacro.
2773 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2774 free_tlist(origline
);
2775 return DIRECTIVE_FOUND
;
2780 StrList
*xsl
= NULL
;
2781 StrList
**xst
= &xsl
;
2785 tline
= tline
->next
;
2787 tline
= expand_id(tline
);
2788 if (!tline
|| (tline
->type
!= TOK_ID
&&
2789 (tline
->type
!= TOK_PREPROC_ID
||
2790 tline
->text
[1] != '$'))) {
2792 "`%%pathsearch' expects a macro identifier as first parameter");
2793 free_tlist(origline
);
2794 return DIRECTIVE_FOUND
;
2796 ctx
= get_ctx(tline
->text
, false);
2798 mname
= tline
->text
;
2800 tline
= expand_smacro(tline
->next
);
2804 while (tok_type_(t
, TOK_WHITESPACE
))
2807 if (!t
|| (t
->type
!= TOK_STRING
&&
2808 t
->type
!= TOK_INTERNAL_STRING
)) {
2809 error(ERR_NONFATAL
, "`%%pathsearch' expects a file name");
2811 free_tlist(origline
);
2812 return DIRECTIVE_FOUND
; /* but we did _something_ */
2816 "trailing garbage after `%%pathsearch' ignored");
2818 if (t
->type
!= TOK_INTERNAL_STRING
)
2819 nasm_unquote(p
, NULL
);
2821 fp
= inc_fopen(p
, &xsl
, &xst
, true);
2824 fclose(fp
); /* Don't actually care about the file */
2826 macro_start
= nasm_malloc(sizeof(*macro_start
));
2827 macro_start
->next
= NULL
;
2828 macro_start
->text
= nasm_quote(p
, strlen(p
));
2829 macro_start
->type
= TOK_STRING
;
2830 macro_start
->a
.mac
= NULL
;
2835 * We now have a macro name, an implicit parameter count of
2836 * zero, and a string token to use as an expansion. Create
2837 * and store an SMacro.
2839 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2841 free_tlist(origline
);
2842 return DIRECTIVE_FOUND
;
2848 tline
= tline
->next
;
2850 tline
= expand_id(tline
);
2851 if (!tline
|| (tline
->type
!= TOK_ID
&&
2852 (tline
->type
!= TOK_PREPROC_ID
||
2853 tline
->text
[1] != '$'))) {
2855 "`%%strlen' expects a macro identifier as first parameter");
2856 free_tlist(origline
);
2857 return DIRECTIVE_FOUND
;
2859 ctx
= get_ctx(tline
->text
, false);
2861 mname
= tline
->text
;
2863 tline
= expand_smacro(tline
->next
);
2867 while (tok_type_(t
, TOK_WHITESPACE
))
2869 /* t should now point to the string */
2870 if (t
->type
!= TOK_STRING
) {
2872 "`%%strlen` requires string as second parameter");
2874 free_tlist(origline
);
2875 return DIRECTIVE_FOUND
;
2878 macro_start
= nasm_malloc(sizeof(*macro_start
));
2879 macro_start
->next
= NULL
;
2880 make_tok_num(macro_start
, nasm_unquote(t
->text
, NULL
));
2881 macro_start
->a
.mac
= NULL
;
2884 * We now have a macro name, an implicit parameter count of
2885 * zero, and a numeric token to use as an expansion. Create
2886 * and store an SMacro.
2888 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2890 free_tlist(origline
);
2891 return DIRECTIVE_FOUND
;
2896 tline
= tline
->next
;
2898 tline
= expand_id(tline
);
2899 if (!tline
|| (tline
->type
!= TOK_ID
&&
2900 (tline
->type
!= TOK_PREPROC_ID
||
2901 tline
->text
[1] != '$'))) {
2903 "`%%strcat' expects a macro identifier as first parameter");
2904 free_tlist(origline
);
2905 return DIRECTIVE_FOUND
;
2907 ctx
= get_ctx(tline
->text
, false);
2909 mname
= tline
->text
;
2911 tline
= expand_smacro(tline
->next
);
2915 for (t
= tline
; t
; t
= t
->next
) {
2917 case TOK_WHITESPACE
:
2920 len
+= t
->a
.len
= nasm_unquote(t
->text
, NULL
);
2923 if (!strcmp(t
->text
, ",")) /* permit comma separators */
2925 /* else fall through */
2928 "non-string passed to `%%strcat' (%d)", t
->type
);
2930 free_tlist(origline
);
2931 return DIRECTIVE_FOUND
;
2935 p
= pp
= nasm_malloc(len
);
2937 for (t
= tline
; t
; t
= t
->next
) {
2938 if (t
->type
== TOK_STRING
) {
2939 memcpy(p
, t
->text
, t
->a
.len
);
2945 * We now have a macro name, an implicit parameter count of
2946 * zero, and a numeric token to use as an expansion. Create
2947 * and store an SMacro.
2949 macro_start
= new_Token(NULL
, TOK_STRING
, NULL
, 0);
2950 macro_start
->text
= nasm_quote(pp
, len
);
2952 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2954 free_tlist(origline
);
2955 return DIRECTIVE_FOUND
;
2964 tline
= tline
->next
;
2966 tline
= expand_id(tline
);
2967 if (!tline
|| (tline
->type
!= TOK_ID
&&
2968 (tline
->type
!= TOK_PREPROC_ID
||
2969 tline
->text
[1] != '$'))) {
2971 "`%%substr' expects a macro identifier as first parameter");
2972 free_tlist(origline
);
2973 return DIRECTIVE_FOUND
;
2975 ctx
= get_ctx(tline
->text
, false);
2977 mname
= tline
->text
;
2979 tline
= expand_smacro(tline
->next
);
2983 while (tok_type_(t
, TOK_WHITESPACE
))
2986 /* t should now point to the string */
2987 if (t
->type
!= TOK_STRING
) {
2989 "`%%substr` requires string as second parameter");
2991 free_tlist(origline
);
2992 return DIRECTIVE_FOUND
;
2997 tokval
.t_type
= TOKEN_INVALID
;
2998 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3002 free_tlist(origline
);
3003 return DIRECTIVE_FOUND
;
3004 } else if (!is_simple(evalresult
)) {
3005 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3007 free_tlist(origline
);
3008 return DIRECTIVE_FOUND
;
3010 a1
= evalresult
->value
-1;
3012 while (tok_type_(tt
, TOK_WHITESPACE
))
3015 a2
= 1; /* Backwards compatibility: one character */
3017 tokval
.t_type
= TOKEN_INVALID
;
3018 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3022 free_tlist(origline
);
3023 return DIRECTIVE_FOUND
;
3024 } else if (!is_simple(evalresult
)) {
3025 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3027 free_tlist(origline
);
3028 return DIRECTIVE_FOUND
;
3030 a2
= evalresult
->value
;
3033 len
= nasm_unquote(t
->text
, NULL
);
3036 if (a1
+a2
> (int64_t)len
)
3039 macro_start
= nasm_malloc(sizeof(*macro_start
));
3040 macro_start
->next
= NULL
;
3041 macro_start
->text
= nasm_quote((a1
< 0) ? "" : t
->text
+a1
, a2
);
3042 macro_start
->type
= TOK_STRING
;
3043 macro_start
->a
.mac
= NULL
;
3046 * We now have a macro name, an implicit parameter count of
3047 * zero, and a numeric token to use as an expansion. Create
3048 * and store an SMacro.
3050 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3052 free_tlist(origline
);
3053 return DIRECTIVE_FOUND
;
3058 casesense
= (i
== PP_ASSIGN
);
3060 tline
= tline
->next
;
3062 tline
= expand_id(tline
);
3063 if (!tline
|| (tline
->type
!= TOK_ID
&&
3064 (tline
->type
!= TOK_PREPROC_ID
||
3065 tline
->text
[1] != '$'))) {
3067 "`%%%sassign' expects a macro identifier",
3068 (i
== PP_IASSIGN
? "i" : ""));
3069 free_tlist(origline
);
3070 return DIRECTIVE_FOUND
;
3072 ctx
= get_ctx(tline
->text
, false);
3074 mname
= tline
->text
;
3076 tline
= expand_smacro(tline
->next
);
3081 tokval
.t_type
= TOKEN_INVALID
;
3083 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3086 free_tlist(origline
);
3087 return DIRECTIVE_FOUND
;
3092 "trailing garbage after expression ignored");
3094 if (!is_simple(evalresult
)) {
3096 "non-constant value given to `%%%sassign'",
3097 (i
== PP_IASSIGN
? "i" : ""));
3098 free_tlist(origline
);
3099 return DIRECTIVE_FOUND
;
3102 macro_start
= nasm_malloc(sizeof(*macro_start
));
3103 macro_start
->next
= NULL
;
3104 make_tok_num(macro_start
, reloc_value(evalresult
));
3105 macro_start
->a
.mac
= NULL
;
3108 * We now have a macro name, an implicit parameter count of
3109 * zero, and a numeric token to use as an expansion. Create
3110 * and store an SMacro.
3112 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3113 free_tlist(origline
);
3114 return DIRECTIVE_FOUND
;
3118 * Syntax is `%line nnn[+mmm] [filename]'
3120 tline
= tline
->next
;
3122 if (!tok_type_(tline
, TOK_NUMBER
)) {
3123 error(ERR_NONFATAL
, "`%%line' expects line number");
3124 free_tlist(origline
);
3125 return DIRECTIVE_FOUND
;
3127 k
= readnum(tline
->text
, &err
);
3129 tline
= tline
->next
;
3130 if (tok_is_(tline
, "+")) {
3131 tline
= tline
->next
;
3132 if (!tok_type_(tline
, TOK_NUMBER
)) {
3133 error(ERR_NONFATAL
, "`%%line' expects line increment");
3134 free_tlist(origline
);
3135 return DIRECTIVE_FOUND
;
3137 m
= readnum(tline
->text
, &err
);
3138 tline
= tline
->next
;
3144 nasm_free(src_set_fname(detoken(tline
, false)));
3146 free_tlist(origline
);
3147 return DIRECTIVE_FOUND
;
3151 "preprocessor directive `%s' not yet implemented",
3155 return DIRECTIVE_FOUND
;
3159 * Ensure that a macro parameter contains a condition code and
3160 * nothing else. Return the condition code index if so, or -1
3163 static int find_cc(Token
* t
)
3169 return -1; /* Probably a %+ without a space */
3172 if (t
->type
!= TOK_ID
)
3176 if (tt
&& (tt
->type
!= TOK_OTHER
|| strcmp(tt
->text
, ",")))
3180 j
= elements(conditions
);
3183 m
= nasm_stricmp(t
->text
, conditions
[k
]);
3199 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3200 * %-n) and MMacro-local identifiers (%%foo).
3202 static Token
*expand_mmac_params(Token
* tline
)
3204 Token
*t
, *tt
, **tail
, *thead
;
3210 if (tline
->type
== TOK_PREPROC_ID
&&
3211 (((tline
->text
[1] == '+' || tline
->text
[1] == '-')
3212 && tline
->text
[2]) || tline
->text
[1] == '%'
3213 || (tline
->text
[1] >= '0' && tline
->text
[1] <= '9'))) {
3215 int type
= 0, cc
; /* type = 0 to placate optimisers */
3222 tline
= tline
->next
;
3225 while (mac
&& !mac
->name
) /* avoid mistaking %reps for macros */
3226 mac
= mac
->next_active
;
3228 error(ERR_NONFATAL
, "`%s': not in a macro call", t
->text
);
3230 switch (t
->text
[1]) {
3232 * We have to make a substitution of one of the
3233 * forms %1, %-1, %+1, %%foo, %0.
3237 snprintf(tmpbuf
, sizeof(tmpbuf
), "%d", mac
->nparam
);
3238 text
= nasm_strdup(tmpbuf
);
3242 snprintf(tmpbuf
, sizeof(tmpbuf
), "..@%"PRIu64
".",
3244 text
= nasm_strcat(tmpbuf
, t
->text
+ 2);
3247 n
= atoi(t
->text
+ 2) - 1;
3248 if (n
>= mac
->nparam
)
3251 if (mac
->nparam
> 1)
3252 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3253 tt
= mac
->params
[n
];
3258 "macro parameter %d is not a condition code",
3263 if (inverse_ccs
[cc
] == -1) {
3265 "condition code `%s' is not invertible",
3270 nasm_strdup(conditions
[inverse_ccs
[cc
]]);
3274 n
= atoi(t
->text
+ 2) - 1;
3275 if (n
>= mac
->nparam
)
3278 if (mac
->nparam
> 1)
3279 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3280 tt
= mac
->params
[n
];
3285 "macro parameter %d is not a condition code",
3290 text
= nasm_strdup(conditions
[cc
]);
3294 n
= atoi(t
->text
+ 1) - 1;
3295 if (n
>= mac
->nparam
)
3298 if (mac
->nparam
> 1)
3299 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3300 tt
= mac
->params
[n
];
3303 for (i
= 0; i
< mac
->paramlen
[n
]; i
++) {
3304 *tail
= new_Token(NULL
, tt
->type
, tt
->text
, 0);
3305 tail
= &(*tail
)->next
;
3309 text
= NULL
; /* we've done it here */
3325 tline
= tline
->next
;
3332 for (; t
&& (tt
= t
->next
) != NULL
; t
= t
->next
)
3334 case TOK_WHITESPACE
:
3335 if (tt
->type
== TOK_WHITESPACE
) {
3336 t
->next
= delete_Token(tt
);
3340 if (tt
->type
== TOK_ID
|| tt
->type
== TOK_NUMBER
) {
3341 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3344 t
->next
= delete_Token(tt
);
3348 if (tt
->type
== TOK_NUMBER
) {
3349 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3352 t
->next
= delete_Token(tt
);
3363 * Expand all single-line macro calls made in the given line.
3364 * Return the expanded version of the line. The original is deemed
3365 * to be destroyed in the process. (In reality we'll just move
3366 * Tokens from input to output a lot of the time, rather than
3367 * actually bothering to destroy and replicate.)
3369 #define DEADMAN_LIMIT (1 << 20)
3371 static Token
*expand_smacro(Token
* tline
)
3373 Token
*t
, *tt
, *mstart
, **tail
, *thead
;
3374 struct hash_table
*smtbl
;
3375 SMacro
*head
= NULL
, *m
;
3378 unsigned int nparam
, sparam
;
3379 int brackets
, rescan
;
3380 Token
*org_tline
= tline
;
3383 int deadman
= DEADMAN_LIMIT
;
3386 * Trick: we should avoid changing the start token pointer since it can
3387 * be contained in "next" field of other token. Because of this
3388 * we allocate a copy of first token and work with it; at the end of
3389 * routine we copy it back
3393 new_Token(org_tline
->next
, org_tline
->type
, org_tline
->text
,
3395 tline
->a
.mac
= org_tline
->a
.mac
;
3396 nasm_free(org_tline
->text
);
3397 org_tline
->text
= NULL
;
3404 while (tline
) { /* main token loop */
3406 error(ERR_NONFATAL
, "interminable macro recursion");
3410 if ((mname
= tline
->text
)) {
3411 /* if this token is a local macro, look in local context */
3414 if (tline
->type
== TOK_ID
|| tline
->type
== TOK_PREPROC_ID
) {
3415 ctx
= get_ctx(mname
, true);
3417 smtbl
= &ctx
->localmac
;
3419 head
= (SMacro
*) hash_findix(smtbl
, mname
);
3422 * We've hit an identifier. As in is_mmacro below, we first
3423 * check whether the identifier is a single-line macro at
3424 * all, then think about checking for parameters if
3427 for (m
= head
; m
; m
= m
->next
)
3428 if (!mstrcmp(m
->name
, mname
, m
->casesense
))
3434 if (m
->nparam
== 0) {
3436 * Simple case: the macro is parameterless. Discard the
3437 * one token that the macro call took, and push the
3438 * expansion back on the to-do stack.
3440 if (!m
->expansion
) {
3441 if (!strcmp("__FILE__", m
->name
)) {
3444 src_get(&num
, &file
);
3445 tline
->text
= nasm_quote(file
, strlen(file
));
3446 tline
->type
= TOK_STRING
;
3450 if (!strcmp("__LINE__", m
->name
)) {
3451 nasm_free(tline
->text
);
3452 make_tok_num(tline
, src_get_linnum());
3455 if (!strcmp("__BITS__", m
->name
)) {
3456 nasm_free(tline
->text
);
3457 make_tok_num(tline
, globalbits
);
3460 tline
= delete_Token(tline
);
3465 * Complicated case: at least one macro with this name
3466 * exists and takes parameters. We must find the
3467 * parameters in the call, count them, find the SMacro
3468 * that corresponds to that form of the macro call, and
3469 * substitute for the parameters when we expand. What a
3472 /*tline = tline->next;
3473 skip_white_(tline); */
3476 while (tok_type_(t
, TOK_SMAC_END
)) {
3477 t
->a
.mac
->in_progress
= false;
3479 t
= tline
->next
= delete_Token(t
);
3482 } while (tok_type_(tline
, TOK_WHITESPACE
));
3483 if (!tok_is_(tline
, "(")) {
3485 * This macro wasn't called with parameters: ignore
3486 * the call. (Behaviour borrowed from gnu cpp.)
3495 sparam
= PARAM_DELTA
;
3496 params
= nasm_malloc(sparam
* sizeof(Token
*));
3497 params
[0] = tline
->next
;
3498 paramsize
= nasm_malloc(sparam
* sizeof(int));
3500 while (true) { /* parameter loop */
3502 * For some unusual expansions
3503 * which concatenates function call
3506 while (tok_type_(t
, TOK_SMAC_END
)) {
3507 t
->a
.mac
->in_progress
= false;
3509 t
= tline
->next
= delete_Token(t
);
3515 "macro call expects terminating `)'");
3518 if (tline
->type
== TOK_WHITESPACE
3520 if (paramsize
[nparam
])
3523 params
[nparam
] = tline
->next
;
3524 continue; /* parameter loop */
3526 if (tline
->type
== TOK_OTHER
3527 && tline
->text
[1] == 0) {
3528 char ch
= tline
->text
[0];
3529 if (ch
== ',' && !paren
&& brackets
<= 0) {
3530 if (++nparam
>= sparam
) {
3531 sparam
+= PARAM_DELTA
;
3532 params
= nasm_realloc(params
,
3537 nasm_realloc(paramsize
,
3541 params
[nparam
] = tline
->next
;
3542 paramsize
[nparam
] = 0;
3544 continue; /* parameter loop */
3547 (brackets
> 0 || (brackets
== 0 &&
3548 !paramsize
[nparam
])))
3550 if (!(brackets
++)) {
3551 params
[nparam
] = tline
->next
;
3552 continue; /* parameter loop */
3555 if (ch
== '}' && brackets
> 0)
3556 if (--brackets
== 0) {
3558 continue; /* parameter loop */
3560 if (ch
== '(' && !brackets
)
3562 if (ch
== ')' && brackets
<= 0)
3568 error(ERR_NONFATAL
, "braces do not "
3569 "enclose all of macro parameter");
3571 paramsize
[nparam
] += white
+ 1;
3573 } /* parameter loop */
3575 while (m
&& (m
->nparam
!= nparam
||
3576 mstrcmp(m
->name
, mname
,
3580 error(ERR_WARNING
| ERR_WARN_MNP
,
3581 "macro `%s' exists, "
3582 "but not taking %d parameters",
3583 mstart
->text
, nparam
);
3586 if (m
&& m
->in_progress
)
3588 if (!m
) { /* in progess or didn't find '(' or wrong nparam */
3590 * Design question: should we handle !tline, which
3591 * indicates missing ')' here, or expand those
3592 * macros anyway, which requires the (t) test a few
3596 nasm_free(paramsize
);
3600 * Expand the macro: we are placed on the last token of the
3601 * call, so that we can easily split the call from the
3602 * following tokens. We also start by pushing an SMAC_END
3603 * token for the cycle removal.
3610 tt
= new_Token(tline
, TOK_SMAC_END
, NULL
, 0);
3612 m
->in_progress
= true;
3614 for (t
= m
->expansion
; t
; t
= t
->next
) {
3615 if (t
->type
>= TOK_SMAC_PARAM
) {
3616 Token
*pcopy
= tline
, **ptail
= &pcopy
;
3620 ttt
= params
[t
->type
- TOK_SMAC_PARAM
];
3621 for (i
= paramsize
[t
->type
- TOK_SMAC_PARAM
];
3624 new_Token(tline
, ttt
->type
, ttt
->text
,
3630 } else if (t
->type
== TOK_PREPROC_Q
) {
3631 tt
= new_Token(tline
, TOK_ID
, mname
, 0);
3633 } else if (t
->type
== TOK_PREPROC_QQ
) {
3634 tt
= new_Token(tline
, TOK_ID
, m
->name
, 0);
3637 tt
= new_Token(tline
, t
->type
, t
->text
, 0);
3643 * Having done that, get rid of the macro call, and clean
3644 * up the parameters.
3647 nasm_free(paramsize
);
3649 continue; /* main token loop */
3654 if (tline
->type
== TOK_SMAC_END
) {
3655 tline
->a
.mac
->in_progress
= false;
3656 tline
= delete_Token(tline
);
3659 tline
= tline
->next
;
3667 * Now scan the entire line and look for successive TOK_IDs that resulted
3668 * after expansion (they can't be produced by tokenize()). The successive
3669 * TOK_IDs should be concatenated.
3670 * Also we look for %+ tokens and concatenate the tokens before and after
3671 * them (without white spaces in between).
3676 while (t
&& t
->type
!= TOK_ID
&& t
->type
!= TOK_PREPROC_ID
)
3680 if (t
->next
->type
== TOK_ID
||
3681 t
->next
->type
== TOK_PREPROC_ID
||
3682 t
->next
->type
== TOK_NUMBER
) {
3683 char *p
= nasm_strcat(t
->text
, t
->next
->text
);
3685 t
->next
= delete_Token(t
->next
);
3688 } else if (t
->next
->type
== TOK_WHITESPACE
&& t
->next
->next
&&
3689 t
->next
->next
->type
== TOK_PREPROC_ID
&&
3690 strcmp(t
->next
->next
->text
, "%+") == 0) {
3691 /* free the next whitespace, the %+ token and next whitespace */
3693 for (i
= 1; i
<= 3; i
++) {
3695 || (i
!= 2 && t
->next
->type
!= TOK_WHITESPACE
))
3697 t
->next
= delete_Token(t
->next
);
3702 /* If we concatenaded something, re-scan the line for macros */
3710 *org_tline
= *thead
;
3711 /* since we just gave text to org_line, don't free it */
3713 delete_Token(thead
);
3715 /* the expression expanded to empty line;
3716 we can't return NULL for some reasons
3717 we just set the line to a single WHITESPACE token. */
3718 memset(org_tline
, 0, sizeof(*org_tline
));
3719 org_tline
->text
= NULL
;
3720 org_tline
->type
= TOK_WHITESPACE
;
3729 * Similar to expand_smacro but used exclusively with macro identifiers
3730 * right before they are fetched in. The reason is that there can be
3731 * identifiers consisting of several subparts. We consider that if there
3732 * are more than one element forming the name, user wants a expansion,
3733 * otherwise it will be left as-is. Example:
3737 * the identifier %$abc will be left as-is so that the handler for %define
3738 * will suck it and define the corresponding value. Other case:
3740 * %define _%$abc cde
3742 * In this case user wants name to be expanded *before* %define starts
3743 * working, so we'll expand %$abc into something (if it has a value;
3744 * otherwise it will be left as-is) then concatenate all successive
3747 static Token
*expand_id(Token
* tline
)
3749 Token
*cur
, *oldnext
= NULL
;
3751 if (!tline
|| !tline
->next
)
3756 (cur
->next
->type
== TOK_ID
||
3757 cur
->next
->type
== TOK_PREPROC_ID
3758 || cur
->next
->type
== TOK_NUMBER
))
3761 /* If identifier consists of just one token, don't expand */
3766 oldnext
= cur
->next
; /* Detach the tail past identifier */
3767 cur
->next
= NULL
; /* so that expand_smacro stops here */
3770 tline
= expand_smacro(tline
);
3773 /* expand_smacro possibly changhed tline; re-scan for EOL */
3775 while (cur
&& cur
->next
)
3778 cur
->next
= oldnext
;
3785 * Determine whether the given line constitutes a multi-line macro
3786 * call, and return the MMacro structure called if so. Doesn't have
3787 * to check for an initial label - that's taken care of in
3788 * expand_mmacro - but must check numbers of parameters. Guaranteed
3789 * to be called with tline->type == TOK_ID, so the putative macro
3790 * name is easy to find.
3792 static MMacro
*is_mmacro(Token
* tline
, Token
*** params_array
)
3798 head
= (MMacro
*) hash_findix(&mmacros
, tline
->text
);
3801 * Efficiency: first we see if any macro exists with the given
3802 * name. If not, we can return NULL immediately. _Then_ we
3803 * count the parameters, and then we look further along the
3804 * list if necessary to find the proper MMacro.
3806 for (m
= head
; m
; m
= m
->next
)
3807 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
3813 * OK, we have a potential macro. Count and demarcate the
3816 count_mmac_params(tline
->next
, &nparam
, ¶ms
);
3819 * So we know how many parameters we've got. Find the MMacro
3820 * structure that handles this number.
3823 if (m
->nparam_min
<= nparam
3824 && (m
->plus
|| nparam
<= m
->nparam_max
)) {
3826 * This one is right. Just check if cycle removal
3827 * prohibits us using it before we actually celebrate...
3829 if (m
->in_progress
) {
3832 "self-reference in multi-line macro `%s'", m
->name
);
3838 * It's right, and we can use it. Add its default
3839 * parameters to the end of our list if necessary.
3841 if (m
->defaults
&& nparam
< m
->nparam_min
+ m
->ndefs
) {
3843 nasm_realloc(params
,
3844 ((m
->nparam_min
+ m
->ndefs
+
3845 1) * sizeof(*params
)));
3846 while (nparam
< m
->nparam_min
+ m
->ndefs
) {
3847 params
[nparam
] = m
->defaults
[nparam
- m
->nparam_min
];
3852 * If we've gone over the maximum parameter count (and
3853 * we're in Plus mode), ignore parameters beyond
3856 if (m
->plus
&& nparam
> m
->nparam_max
)
3857 nparam
= m
->nparam_max
;
3859 * Then terminate the parameter list, and leave.
3861 if (!params
) { /* need this special case */
3862 params
= nasm_malloc(sizeof(*params
));
3865 params
[nparam
] = NULL
;
3866 *params_array
= params
;
3870 * This one wasn't right: look for the next one with the
3873 for (m
= m
->next
; m
; m
= m
->next
)
3874 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
3879 * After all that, we didn't find one with the right number of
3880 * parameters. Issue a warning, and fail to expand the macro.
3882 error(ERR_WARNING
| ERR_WARN_MNP
,
3883 "macro `%s' exists, but not taking %d parameters",
3884 tline
->text
, nparam
);
3890 * Expand the multi-line macro call made by the given line, if
3891 * there is one to be expanded. If there is, push the expansion on
3892 * istk->expansion and return 1. Otherwise return 0.
3894 static int expand_mmacro(Token
* tline
)
3896 Token
*startline
= tline
;
3897 Token
*label
= NULL
;
3898 int dont_prepend
= 0;
3899 Token
**params
, *t
, *mtok
, *tt
;
3902 int i
, nparam
, *paramlen
;
3907 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
3908 if (!tok_type_(t
, TOK_ID
) && !tok_type_(t
, TOK_PREPROC_ID
))
3911 m
= is_mmacro(t
, ¶ms
);
3917 * We have an id which isn't a macro call. We'll assume
3918 * it might be a label; we'll also check to see if a
3919 * colon follows it. Then, if there's another id after
3920 * that lot, we'll check it again for macro-hood.
3924 if (tok_type_(t
, TOK_WHITESPACE
))
3925 last
= t
, t
= t
->next
;
3926 if (tok_is_(t
, ":")) {
3928 last
= t
, t
= t
->next
;
3929 if (tok_type_(t
, TOK_WHITESPACE
))
3930 last
= t
, t
= t
->next
;
3932 if (!tok_type_(t
, TOK_ID
) || (m
= is_mmacro(t
, ¶ms
)) == NULL
)
3940 * Fix up the parameters: this involves stripping leading and
3941 * trailing whitespace, then stripping braces if they are
3944 for (nparam
= 0; params
[nparam
]; nparam
++) ;
3945 paramlen
= nparam
? nasm_malloc(nparam
* sizeof(*paramlen
)) : NULL
;
3947 for (i
= 0; params
[i
]; i
++) {
3949 int comma
= (!m
->plus
|| i
< nparam
- 1);
3953 if (tok_is_(t
, "{"))
3954 t
= t
->next
, brace
= true, comma
= false;
3958 if (comma
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, ","))
3959 break; /* ... because we have hit a comma */
3960 if (comma
&& t
->type
== TOK_WHITESPACE
3961 && tok_is_(t
->next
, ","))
3962 break; /* ... or a space then a comma */
3963 if (brace
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, "}"))
3964 break; /* ... or a brace */
3971 * OK, we have a MMacro structure together with a set of
3972 * parameters. We must now go through the expansion and push
3973 * copies of each Line on to istk->expansion. Substitution of
3974 * parameter tokens and macro-local tokens doesn't get done
3975 * until the single-line macro substitution process; this is
3976 * because delaying them allows us to change the semantics
3977 * later through %rotate.
3979 * First, push an end marker on to istk->expansion, mark this
3980 * macro as in progress, and set up its invocation-specific
3983 ll
= nasm_malloc(sizeof(Line
));
3984 ll
->next
= istk
->expansion
;
3987 istk
->expansion
= ll
;
3989 m
->in_progress
= true;
3994 m
->paramlen
= paramlen
;
3995 m
->unique
= unique
++;
3998 m
->next_active
= istk
->mstk
;
4001 for (l
= m
->expansion
; l
; l
= l
->next
) {
4004 ll
= nasm_malloc(sizeof(Line
));
4005 ll
->finishes
= NULL
;
4006 ll
->next
= istk
->expansion
;
4007 istk
->expansion
= ll
;
4010 for (t
= l
->first
; t
; t
= t
->next
) {
4014 tt
= *tail
= new_Token(NULL
, TOK_ID
, mname
, 0);
4016 case TOK_PREPROC_QQ
:
4017 tt
= *tail
= new_Token(NULL
, TOK_ID
, m
->name
, 0);
4019 case TOK_PREPROC_ID
:
4020 if (t
->text
[1] == '0' && t
->text
[2] == '0') {
4028 tt
= *tail
= new_Token(NULL
, x
->type
, x
->text
, 0);
4037 * If we had a label, push it on as the first line of
4038 * the macro expansion.
4041 if (dont_prepend
< 0)
4042 free_tlist(startline
);
4044 ll
= nasm_malloc(sizeof(Line
));
4045 ll
->finishes
= NULL
;
4046 ll
->next
= istk
->expansion
;
4047 istk
->expansion
= ll
;
4048 ll
->first
= startline
;
4049 if (!dont_prepend
) {
4051 label
= label
->next
;
4052 label
->next
= tt
= new_Token(NULL
, TOK_OTHER
, ":", 0);
4057 list
->uplevel(m
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
4063 * Since preprocessor always operate only on the line that didn't
4064 * arrived yet, we should always use ERR_OFFBY1. Also since user
4065 * won't want to see same error twice (preprocessing is done once
4066 * per pass) we will want to show errors only during pass one.
4068 static void error(int severity
, const char *fmt
, ...)
4073 /* If we're in a dead branch of IF or something like it, ignore the error */
4074 if (istk
&& istk
->conds
&& !emitting(istk
->conds
->state
))
4078 vsnprintf(buff
, sizeof(buff
), fmt
, arg
);
4081 if (istk
&& istk
->mstk
&& istk
->mstk
->name
)
4082 _error(severity
| ERR_PASS1
, "(%s:%d) %s", istk
->mstk
->name
,
4083 istk
->mstk
->lineno
, buff
);
4085 _error(severity
| ERR_PASS1
, "%s", buff
);
4089 pp_reset(char *file
, int apass
, efunc errfunc
, evalfunc eval
,
4090 ListGen
* listgen
, StrList
**deplist
)
4094 istk
= nasm_malloc(sizeof(Include
));
4097 istk
->expansion
= NULL
;
4099 istk
->fp
= fopen(file
, "r");
4101 src_set_fname(nasm_strdup(file
));
4105 error(ERR_FATAL
| ERR_NOFILE
, "unable to open input file `%s'",
4108 nested_mac_count
= 0;
4109 nested_rep_count
= 0;
4112 if (tasm_compatible_mode
) {
4113 stdmacpos
= nasm_stdmac
;
4115 stdmacpos
= nasm_stdmac_after_tasm
;
4117 any_extrastdmac
= extrastdmac
&& *extrastdmac
;
4122 dephead
= deptail
= deplist
;
4124 StrList
*sl
= nasm_malloc(strlen(file
)+1+sizeof sl
->next
);
4126 strcpy(sl
->str
, file
);
4128 deptail
= &sl
->next
;
4132 static char *pp_getline(void)
4139 * Fetch a tokenized line, either from the macro-expansion
4140 * buffer or from the input file.
4143 while (istk
->expansion
&& istk
->expansion
->finishes
) {
4144 Line
*l
= istk
->expansion
;
4145 if (!l
->finishes
->name
&& l
->finishes
->in_progress
> 1) {
4149 * This is a macro-end marker for a macro with no
4150 * name, which means it's not really a macro at all
4151 * but a %rep block, and the `in_progress' field is
4152 * more than 1, meaning that we still need to
4153 * repeat. (1 means the natural last repetition; 0
4154 * means termination by %exitrep.) We have
4155 * therefore expanded up to the %endrep, and must
4156 * push the whole block on to the expansion buffer
4157 * again. We don't bother to remove the macro-end
4158 * marker: we'd only have to generate another one
4161 l
->finishes
->in_progress
--;
4162 for (l
= l
->finishes
->expansion
; l
; l
= l
->next
) {
4163 Token
*t
, *tt
, **tail
;
4165 ll
= nasm_malloc(sizeof(Line
));
4166 ll
->next
= istk
->expansion
;
4167 ll
->finishes
= NULL
;
4171 for (t
= l
->first
; t
; t
= t
->next
) {
4172 if (t
->text
|| t
->type
== TOK_WHITESPACE
) {
4174 new_Token(NULL
, t
->type
, t
->text
, 0);
4179 istk
->expansion
= ll
;
4183 * Check whether a `%rep' was started and not ended
4184 * within this macro expansion. This can happen and
4185 * should be detected. It's a fatal error because
4186 * I'm too confused to work out how to recover
4192 "defining with name in expansion");
4193 else if (istk
->mstk
->name
)
4195 "`%%rep' without `%%endrep' within"
4196 " expansion of macro `%s'",
4201 * FIXME: investigate the relationship at this point between
4202 * istk->mstk and l->finishes
4205 MMacro
*m
= istk
->mstk
;
4206 istk
->mstk
= m
->next_active
;
4209 * This was a real macro call, not a %rep, and
4210 * therefore the parameter information needs to
4213 nasm_free(m
->params
);
4214 free_tlist(m
->iline
);
4215 nasm_free(m
->paramlen
);
4216 l
->finishes
->in_progress
= false;
4220 istk
->expansion
= l
->next
;
4222 list
->downlevel(LIST_MACRO
);
4225 while (1) { /* until we get a line we can use */
4227 if (istk
->expansion
) { /* from a macro expansion */
4229 Line
*l
= istk
->expansion
;
4231 istk
->mstk
->lineno
++;
4233 istk
->expansion
= l
->next
;
4235 p
= detoken(tline
, false);
4236 list
->line(LIST_MACRO
, p
);
4241 if (line
) { /* from the current input file */
4242 line
= prepreproc(line
);
4243 tline
= tokenize(line
);
4248 * The current file has ended; work down the istk
4255 "expected `%%endif' before end of file");
4256 /* only set line and file name if there's a next node */
4258 src_set_linnum(i
->lineno
);
4259 nasm_free(src_set_fname(i
->fname
));
4262 list
->downlevel(LIST_INCLUDE
);
4270 * We must expand MMacro parameters and MMacro-local labels
4271 * _before_ we plunge into directive processing, to cope
4272 * with things like `%define something %1' such as STRUC
4273 * uses. Unless we're _defining_ a MMacro, in which case
4274 * those tokens should be left alone to go into the
4275 * definition; and unless we're in a non-emitting
4276 * condition, in which case we don't want to meddle with
4279 if (!defining
&& !(istk
->conds
&& !emitting(istk
->conds
->state
))
4280 && !(istk
->mstk
&& !istk
->mstk
->in_progress
))
4281 tline
= expand_mmac_params(tline
);
4284 * Check the line to see if it's a preprocessor directive.
4286 if (do_directive(tline
) == DIRECTIVE_FOUND
) {
4288 } else if (defining
) {
4290 * We're defining a multi-line macro. We emit nothing
4292 * shove the tokenized line on to the macro definition.
4294 Line
*l
= nasm_malloc(sizeof(Line
));
4295 l
->next
= defining
->expansion
;
4298 defining
->expansion
= l
;
4300 } else if (istk
->conds
&& !emitting(istk
->conds
->state
)) {
4302 * We're in a non-emitting branch of a condition block.
4303 * Emit nothing at all, not even a blank line: when we
4304 * emerge from the condition we'll give a line-number
4305 * directive so we keep our place correctly.
4309 } else if (istk
->mstk
&& !istk
->mstk
->in_progress
) {
4311 * We're in a %rep block which has been terminated, so
4312 * we're walking through to the %endrep without
4313 * emitting anything. Emit nothing at all, not even a
4314 * blank line: when we emerge from the %rep block we'll
4315 * give a line-number directive so we keep our place
4321 tline
= expand_smacro(tline
);
4322 if (!expand_mmacro(tline
)) {
4324 * De-tokenize the line again, and emit it.
4326 line
= detoken(tline
, true);
4330 continue; /* expand_mmacro calls free_tlist */
4338 static void pp_cleanup(int pass
)
4341 error(ERR_NONFATAL
, "end of file while still defining macro `%s'",
4343 free_mmacro(defining
);
4352 nasm_free(i
->fname
);
4357 nasm_free(src_set_fname(NULL
));
4362 while ((i
= ipath
)) {
4371 void pp_include_path(char *path
)
4375 i
= nasm_malloc(sizeof(IncPath
));
4376 i
->path
= path
? nasm_strdup(path
) : NULL
;
4379 if (ipath
!= NULL
) {
4381 while (j
->next
!= NULL
)
4389 void pp_pre_include(char *fname
)
4391 Token
*inc
, *space
, *name
;
4394 name
= new_Token(NULL
, TOK_INTERNAL_STRING
, fname
, 0);
4395 space
= new_Token(name
, TOK_WHITESPACE
, NULL
, 0);
4396 inc
= new_Token(space
, TOK_PREPROC_ID
, "%include", 0);
4398 l
= nasm_malloc(sizeof(Line
));
4405 void pp_pre_define(char *definition
)
4411 equals
= strchr(definition
, '=');
4412 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4413 def
= new_Token(space
, TOK_PREPROC_ID
, "%define", 0);
4416 space
->next
= tokenize(definition
);
4420 l
= nasm_malloc(sizeof(Line
));
4427 void pp_pre_undefine(char *definition
)
4432 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4433 def
= new_Token(space
, TOK_PREPROC_ID
, "%undef", 0);
4434 space
->next
= tokenize(definition
);
4436 l
= nasm_malloc(sizeof(Line
));
4444 * Added by Keith Kanios:
4446 * This function is used to assist with "runtime" preprocessor
4447 * directives. (e.g. pp_runtime("%define __BITS__ 64");)
4449 * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
4450 * PASS A VALID STRING TO THIS FUNCTION!!!!!
4453 void pp_runtime(char *definition
)
4457 def
= tokenize(definition
);
4458 if(do_directive(def
) == NO_DIRECTIVE_FOUND
)
4463 void pp_extra_stdmac(const macros_t
*macros
)
4465 extrastdmac
= macros
;
4468 static void make_tok_num(Token
* tok
, int64_t val
)
4471 snprintf(numbuf
, sizeof(numbuf
), "%"PRId64
"", val
);
4472 tok
->text
= nasm_strdup(numbuf
);
4473 tok
->type
= TOK_NUMBER
;