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
55 typedef struct SMacro SMacro
;
56 typedef struct MMacro MMacro
;
57 typedef struct Context Context
;
58 typedef struct Token Token
;
59 typedef struct Blocks Blocks
;
60 typedef struct Line Line
;
61 typedef struct Include Include
;
62 typedef struct Cond Cond
;
63 typedef struct IncPath IncPath
;
66 * Note on the storage of both SMacro and MMacros: the hash table
67 * indexes them case-insensitively, and we then have to go through a
68 * linked list of potential case aliases (and, for MMacros, parameter
69 * ranges); this is to preserve the matching semantics of the earlier
70 * code. If the number of case aliases for a specific macro is a
71 * performance issue, you may want to reconsider your coding style.
75 * Store the definition of a single-line macro.
87 * Store the definition of a multi-line macro. This is also used to
88 * store the interiors of `%rep...%endrep' blocks, which are
89 * effectively self-re-invoking multi-line macros which simply
90 * don't have a name or bother to appear in the hash tables. %rep
91 * blocks are signified by having a NULL `name' field.
93 * In a MMacro describing a `%rep' block, the `in_progress' field
94 * isn't merely boolean, but gives the number of repeats left to
97 * The `next' field is used for storing MMacros in hash tables; the
98 * `next_active' field is for stacking them on istk entries.
100 * When a MMacro is being expanded, `params', `iline', `nparam',
101 * `paramlen', `rotate' and `unique' are local to the invocation.
106 int nparam_min
, nparam_max
;
108 bool plus
; /* is the last parameter greedy? */
109 bool nolist
; /* is this macro listing-inhibited? */
111 Token
*dlist
; /* All defaults as one list */
112 Token
**defaults
; /* Parameter default pointers */
113 int ndefs
; /* number of default parameters */
117 MMacro
*rep_nest
; /* used for nesting %rep */
118 Token
**params
; /* actual parameters */
119 Token
*iline
; /* invocation line */
120 unsigned int nparam
, rotate
;
123 int lineno
; /* Current line number on expansion */
127 * The context stack is composed of a linked list of these.
132 struct hash_table localmac
;
137 * This is the internal form which we break input lines up into.
138 * Typically stored in linked lists.
140 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
141 * necessarily used as-is, but is intended to denote the number of
142 * the substituted parameter. So in the definition
144 * %define a(x,y) ( (x) & ~(y) )
146 * the token representing `x' will have its type changed to
147 * TOK_SMAC_PARAM, but the one representing `y' will be
150 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
151 * which doesn't need quotes around it. Used in the pre-include
152 * mechanism as an alternative to trying to find a sensible type of
153 * quote to use on the filename we were passed.
156 TOK_NONE
= 0, TOK_WHITESPACE
, TOK_COMMENT
, TOK_ID
,
157 TOK_PREPROC_ID
, TOK_STRING
,
158 TOK_NUMBER
, TOK_FLOAT
, TOK_SMAC_END
, TOK_OTHER
,
160 TOK_PREPROC_Q
, TOK_PREPROC_QQ
,
161 TOK_SMAC_PARAM
, /* MUST BE LAST IN THE LIST!!! */
162 TOK_MAX
= INT_MAX
/* Keep compiler from reducing the range */
168 SMacro
*mac
; /* associated macro for TOK_SMAC_END */
169 enum pp_token_type type
;
173 * Multi-line macro definitions are stored as a linked list of
174 * these, which is essentially a container to allow several linked
177 * Note that in this module, linked lists are treated as stacks
178 * wherever possible. For this reason, Lines are _pushed_ on to the
179 * `expansion' field in MMacro structures, so that the linked list,
180 * if walked, would give the macro lines in reverse order; this
181 * means that we can walk the list when expanding a macro, and thus
182 * push the lines on to the `expansion' field in _istk_ in reverse
183 * order (so that when popped back off they are in the right
184 * order). It may seem cockeyed, and it relies on my design having
185 * an even number of steps in, but it works...
187 * Some of these structures, rather than being actual lines, are
188 * markers delimiting the end of the expansion of a given macro.
189 * This is for use in the cycle-tracking and %rep-handling code.
190 * Such structures have `finishes' non-NULL, and `first' NULL. All
191 * others have `finishes' NULL, but `first' may still be NULL if
201 * To handle an arbitrary level of file inclusion, we maintain a
202 * stack (ie linked list) of these things.
211 MMacro
*mstk
; /* stack of active macros/reps */
215 * Include search path. This is simply a list of strings which get
216 * prepended, in turn, to the name of an include file, in an
217 * attempt to find the file if it's not in the current directory.
225 * Conditional assembly: we maintain a separate stack of these for
226 * each level of file inclusion. (The only reason we keep the
227 * stacks separate is to ensure that a stray `%endif' in a file
228 * included from within the true branch of a `%if' won't terminate
229 * it and cause confusion: instead, rightly, it'll cause an error.)
237 * These states are for use just after %if or %elif: IF_TRUE
238 * means the condition has evaluated to truth so we are
239 * currently emitting, whereas IF_FALSE means we are not
240 * currently emitting but will start doing so if a %else comes
241 * up. In these states, all directives are admissible: %elif,
242 * %else and %endif. (And of course %if.)
244 COND_IF_TRUE
, COND_IF_FALSE
,
246 * These states come up after a %else: ELSE_TRUE means we're
247 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
248 * any %elif or %else will cause an error.
250 COND_ELSE_TRUE
, COND_ELSE_FALSE
,
252 * This state means that we're not emitting now, and also that
253 * nothing until %endif will be emitted at all. It's for use in
254 * two circumstances: (i) when we've had our moment of emission
255 * and have now started seeing %elifs, and (ii) when the
256 * condition construct in question is contained within a
257 * non-emitting branch of a larger condition construct.
261 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
264 * These defines are used as the possible return values for do_directive
266 #define NO_DIRECTIVE_FOUND 0
267 #define DIRECTIVE_FOUND 1
270 * Condition codes. Note that we use c_ prefix not C_ because C_ is
271 * used in nasm.h for the "real" condition codes. At _this_ level,
272 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
273 * ones, so we need a different enum...
275 static const char * const conditions
[] = {
276 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
277 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
278 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
281 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_CXZ
, c_E
, c_ECXZ
, c_G
, c_GE
, c_L
, c_LE
,
282 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, c_NE
, c_NG
, c_NGE
, c_NL
, c_NLE
, c_NO
,
283 c_NP
, c_NS
, c_NZ
, c_O
, c_P
, c_PE
, c_PO
, c_RCXZ
, c_S
, c_Z
,
286 static const enum pp_conds inverse_ccs
[] = {
287 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, -1, c_NE
, -1, c_NG
, c_NGE
, c_NL
, c_NLE
,
288 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
,
289 c_Z
, c_NO
, c_NP
, c_PO
, c_PE
, -1, c_NS
, c_NZ
295 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
296 static int is_condition(enum preproc_token arg
)
298 return PP_IS_COND(arg
) || (arg
== PP_ELSE
) || (arg
== PP_ENDIF
);
301 /* For TASM compatibility we need to be able to recognise TASM compatible
302 * conditional compilation directives. Using the NASM pre-processor does
303 * not work, so we look for them specifically from the following list and
304 * then jam in the equivalent NASM directive into the input stream.
308 TM_ARG
, TM_ELIF
, TM_ELSE
, TM_ENDIF
, TM_IF
, TM_IFDEF
, TM_IFDIFI
,
309 TM_IFNDEF
, TM_INCLUDE
, TM_LOCAL
312 static const char * const tasm_directives
[] = {
313 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
314 "ifndef", "include", "local"
317 static int StackSize
= 4;
318 static char *StackPointer
= "ebp";
319 static int ArgOffset
= 8;
320 static int LocalOffset
= 0;
322 static Context
*cstk
;
323 static Include
*istk
;
324 static IncPath
*ipath
= NULL
;
326 static efunc _error
; /* Pointer to client-provided error reporting function */
327 static evalfunc evaluate
;
329 static int pass
; /* HACK: pass 0 = generate dependencies only */
330 static StrList
**dephead
, **deptail
; /* Dependency list */
332 static uint64_t unique
; /* unique identifier numbers */
334 static Line
*predef
= NULL
;
336 static ListGen
*list
;
339 * The current set of multi-line macros we have defined.
341 static struct hash_table mmacros
;
344 * The current set of single-line macros we have defined.
346 static struct hash_table smacros
;
349 * The multi-line macro we are currently defining, or the %rep
350 * block we are currently reading, if any.
352 static MMacro
*defining
;
355 * The number of macro parameters to allocate space for at a time.
357 #define PARAM_DELTA 16
360 * The standard macro set: defined in macros.c in the array nasm_stdmac.
361 * This gives our position in the macro set, when we're processing it.
363 static const char * const *stdmacpos
;
366 * The extra standard macros that come from the object format, if
369 static const char * const *extrastdmac
= NULL
;
370 bool any_extrastdmac
;
373 * Tokens are allocated in blocks to improve speed
375 #define TOKEN_BLOCKSIZE 4096
376 static Token
*freeTokens
= NULL
;
382 static Blocks blocks
= { NULL
, NULL
};
385 * Forward declarations.
387 static Token
*expand_mmac_params(Token
* tline
);
388 static Token
*expand_smacro(Token
* tline
);
389 static Token
*expand_id(Token
* tline
);
390 static Context
*get_ctx(char *name
, bool all_contexts
);
391 static void make_tok_num(Token
* tok
, int64_t val
);
392 static void error(int severity
, const char *fmt
, ...);
393 static void *new_Block(size_t size
);
394 static void delete_Blocks(void);
395 static Token
*new_Token(Token
* next
, enum pp_token_type type
, char *text
, int txtlen
);
396 static Token
*delete_Token(Token
* t
);
399 * Macros for safe checking of token pointers, avoid *(NULL)
401 #define tok_type_(x,t) ((x) && (x)->type == (t))
402 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
403 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
404 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
406 /* Handle TASM specific directives, which do not contain a % in
407 * front of them. We do it here because I could not find any other
408 * place to do it for the moment, and it is a hack (ideally it would
409 * be nice to be able to use the NASM pre-processor to do it).
411 static char *check_tasm_directive(char *line
)
413 int32_t i
, j
, k
, m
, len
;
414 char *p
= line
, *oldline
, oldchar
;
416 /* Skip whitespace */
417 while (isspace(*p
) && *p
!= 0)
420 /* Binary search for the directive name */
422 j
= elements(tasm_directives
);
424 while (!isspace(p
[len
]) && p
[len
] != 0)
431 m
= nasm_stricmp(p
, tasm_directives
[k
]);
433 /* We have found a directive, so jam a % in front of it
434 * so that NASM will then recognise it as one if it's own.
439 line
= nasm_malloc(len
+ 2);
441 if (k
== TM_IFDIFI
) {
442 /* NASM does not recognise IFDIFI, so we convert it to
443 * %ifdef BOGUS. This is not used in NASM comaptible
444 * code, but does need to parse for the TASM macro
447 strcpy(line
+ 1, "ifdef BOGUS");
449 memcpy(line
+ 1, p
, len
+ 1);
464 * The pre-preprocessing stage... This function translates line
465 * number indications as they emerge from GNU cpp (`# lineno "file"
466 * flags') into NASM preprocessor line number indications (`%line
469 static char *prepreproc(char *line
)
472 char *fname
, *oldline
;
474 if (line
[0] == '#' && line
[1] == ' ') {
477 lineno
= atoi(fname
);
478 fname
+= strspn(fname
, "0123456789 ");
481 fnlen
= strcspn(fname
, "\"");
482 line
= nasm_malloc(20 + fnlen
);
483 snprintf(line
, 20 + fnlen
, "%%line %d %.*s", lineno
, fnlen
, fname
);
486 if (tasm_compatible_mode
)
487 return check_tasm_directive(line
);
492 * Free a linked list of tokens.
494 static void free_tlist(Token
* list
)
497 list
= delete_Token(list
);
502 * Free a linked list of lines.
504 static void free_llist(Line
* list
)
510 free_tlist(l
->first
);
518 static void free_mmacro(MMacro
* m
)
521 free_tlist(m
->dlist
);
522 nasm_free(m
->defaults
);
523 free_llist(m
->expansion
);
528 * Free all currently defined macros, and free the hash tables
530 static void free_smacro_table(struct hash_table
*smt
)
534 struct hash_tbl_node
*it
= NULL
;
536 while ((s
= hash_iterate(smt
, &it
, &key
)) != NULL
) {
537 nasm_free((void *)key
);
539 SMacro
*ns
= s
->next
;
541 free_tlist(s
->expansion
);
549 static void free_mmacro_table(struct hash_table
*mmt
)
553 struct hash_tbl_node
*it
= NULL
;
556 while ((m
= hash_iterate(mmt
, &it
, &key
)) != NULL
) {
557 nasm_free((void *)key
);
559 MMacro
*nm
= m
->next
;
567 static void free_macros(void)
569 free_smacro_table(&smacros
);
570 free_mmacro_table(&mmacros
);
574 * Initialize the hash tables
576 static void init_macros(void)
578 hash_init(&smacros
, HASH_LARGE
);
579 hash_init(&mmacros
, HASH_LARGE
);
583 * Pop the context stack.
585 static void ctx_pop(void)
590 free_smacro_table(&c
->localmac
);
596 * Search for a key in the hash index; adding it if necessary
597 * (in which case we initialize the data pointer to NULL.)
600 hash_findi_add(struct hash_table
*hash
, const char *str
)
602 struct hash_insert hi
;
606 r
= hash_findi(hash
, str
, &hi
);
610 strx
= nasm_strdup(str
); /* Use a more efficient allocator here? */
611 return hash_add(&hi
, strx
, NULL
);
615 * Like hash_findi, but returns the data element rather than a pointer
616 * to it. Used only when not adding a new element, hence no third
620 hash_findix(struct hash_table
*hash
, const char *str
)
624 p
= hash_findi(hash
, str
, NULL
);
625 return p
? *p
: NULL
;
628 #define BUF_DELTA 512
630 * Read a line from the top file in istk, handling multiple CR/LFs
631 * at the end of the line read, and handling spurious ^Zs. Will
632 * return lines from the standard macro set if this has not already
635 static char *read_line(void)
637 char *buffer
, *p
, *q
;
638 int bufsize
, continued_count
;
642 char *ret
= nasm_strdup(*stdmacpos
++);
643 if (!*stdmacpos
&& any_extrastdmac
) {
644 stdmacpos
= extrastdmac
;
645 any_extrastdmac
= false;
649 * Nasty hack: here we push the contents of `predef' on
650 * to the top-level expansion stack, since this is the
651 * most convenient way to implement the pre-include and
652 * pre-define features.
656 Token
*head
, **tail
, *t
;
658 for (pd
= predef
; pd
; pd
= pd
->next
) {
661 for (t
= pd
->first
; t
; t
= t
->next
) {
662 *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
663 tail
= &(*tail
)->next
;
665 l
= nasm_malloc(sizeof(Line
));
666 l
->next
= istk
->expansion
;
679 buffer
= nasm_malloc(BUF_DELTA
);
683 q
= fgets(p
, bufsize
- (p
- buffer
), istk
->fp
);
687 if (p
> buffer
&& p
[-1] == '\n') {
688 /* Convert backslash-CRLF line continuation sequences into
689 nothing at all (for DOS and Windows) */
690 if (((p
- 2) > buffer
) && (p
[-3] == '\\') && (p
[-2] == '\r')) {
695 /* Also convert backslash-LF line continuation sequences into
696 nothing at all (for Unix) */
697 else if (((p
- 1) > buffer
) && (p
[-2] == '\\')) {
705 if (p
- buffer
> bufsize
- 10) {
706 int32_t offset
= p
- buffer
;
707 bufsize
+= BUF_DELTA
;
708 buffer
= nasm_realloc(buffer
, bufsize
);
709 p
= buffer
+ offset
; /* prevent stale-pointer problems */
713 if (!q
&& p
== buffer
) {
718 src_set_linnum(src_get_linnum() + istk
->lineinc
+
719 (continued_count
* istk
->lineinc
));
722 * Play safe: remove CRs as well as LFs, if any of either are
723 * present at the end of the line.
725 while (--p
>= buffer
&& (*p
== '\n' || *p
== '\r'))
729 * Handle spurious ^Z, which may be inserted into source files
730 * by some file transfer utilities.
732 buffer
[strcspn(buffer
, "\032")] = '\0';
734 list
->line(LIST_READ
, buffer
);
740 * Tokenize a line of text. This is a very simple process since we
741 * don't need to parse the value out of e.g. numeric tokens: we
742 * simply split one string into many.
744 static Token
*tokenize(char *line
)
747 enum pp_token_type type
;
749 Token
*t
, **tail
= &list
;
756 ((*p
== '-' || *p
== '+') && isdigit(p
[1])) ||
757 ((*p
== '+') && (isspace(p
[1]) || !p
[1]))) {
762 type
= TOK_PREPROC_ID
;
763 } else if (*p
== '{') {
765 while (*p
&& *p
!= '}') {
772 type
= TOK_PREPROC_ID
;
773 } else if (*p
== '?') {
774 type
= TOK_PREPROC_Q
; /* %? */
777 type
= TOK_PREPROC_QQ
; /* %?? */
780 } else if (isidchar(*p
) ||
781 ((*p
== '!' || *p
== '%' || *p
== '$') &&
786 while (isidchar(*p
));
787 type
= TOK_PREPROC_ID
;
793 } else if (isidstart(*p
) || (*p
== '$' && isidstart(p
[1]))) {
796 while (*p
&& isidchar(*p
))
798 } else if (*p
== '\'' || *p
== '"') {
805 while (*p
&& *p
!= c
)
811 error(ERR_WARNING
, "unterminated string");
812 /* Handling unterminated strings by UNV */
815 } else if (isnumstart(*p
)) {
817 bool is_float
= false;
833 if (!is_hex
&& (c
== 'e' || c
== 'E')) {
835 if (*p
== '+' || *p
== '-') {
836 /* e can only be followed by +/- if it is either a
837 prefixed hex number or a floating-point number */
841 } else if (c
== 'H' || c
== 'h' || c
== 'X' || c
== 'x') {
843 } else if (c
== 'P' || c
== 'p') {
845 if (*p
== '+' || *p
== '-')
847 } else if (isnumchar(c
) || c
== '_')
850 /* we need to deal with consequences of the legacy
851 parser, like "1.nolist" being two tokens
852 (TOK_NUMBER, TOK_ID) here; at least give it
853 a shot for now. In the future, we probably need
854 a flex-based scanner with proper pattern matching
855 to do it as well as it can be done. Nothing in
856 the world is going to help the person who wants
857 0x123.p16 interpreted as two tokens, though. */
862 if (isdigit(*r
) || (is_hex
&& isxdigit(*r
)) ||
863 (!is_hex
&& (*r
== 'e' || *r
== 'E')) ||
864 (*r
== 'p' || *r
== 'P')) {
868 break; /* Terminate the token */
872 p
--; /* Point to first character beyond number */
874 if (has_e
&& !is_hex
) {
875 /* 1e13 is floating-point, but 1e13h is not */
879 type
= is_float
? TOK_FLOAT
: TOK_NUMBER
;
880 } else if (isspace(*p
)) {
881 type
= TOK_WHITESPACE
;
883 while (*p
&& isspace(*p
))
886 * Whitespace just before end-of-line is discarded by
887 * pretending it's a comment; whitespace just before a
888 * comment gets lumped into the comment.
890 if (!*p
|| *p
== ';') {
895 } else if (*p
== ';') {
901 * Anything else is an operator of some kind. We check
902 * for all the double-character operators (>>, <<, //,
903 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
904 * else is a single-character operator.
907 if ((p
[0] == '>' && p
[1] == '>') ||
908 (p
[0] == '<' && p
[1] == '<') ||
909 (p
[0] == '/' && p
[1] == '/') ||
910 (p
[0] == '<' && p
[1] == '=') ||
911 (p
[0] == '>' && p
[1] == '=') ||
912 (p
[0] == '=' && p
[1] == '=') ||
913 (p
[0] == '!' && p
[1] == '=') ||
914 (p
[0] == '<' && p
[1] == '>') ||
915 (p
[0] == '&' && p
[1] == '&') ||
916 (p
[0] == '|' && p
[1] == '|') ||
917 (p
[0] == '^' && p
[1] == '^')) {
923 /* Handling unterminated string by UNV */
926 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
927 t->text[p-line] = *line;
931 if (type
!= TOK_COMMENT
) {
932 *tail
= t
= new_Token(NULL
, type
, line
, p
- line
);
941 * this function allocates a new managed block of memory and
942 * returns a pointer to the block. The managed blocks are
943 * deleted only all at once by the delete_Blocks function.
945 static void *new_Block(size_t size
)
949 /* first, get to the end of the linked list */
952 /* now allocate the requested chunk */
953 b
->chunk
= nasm_malloc(size
);
955 /* now allocate a new block for the next request */
956 b
->next
= nasm_malloc(sizeof(Blocks
));
957 /* and initialize the contents of the new block */
958 b
->next
->next
= NULL
;
959 b
->next
->chunk
= NULL
;
964 * this function deletes all managed blocks of memory
966 static void delete_Blocks(void)
968 Blocks
*a
, *b
= &blocks
;
971 * keep in mind that the first block, pointed to by blocks
972 * is a static and not dynamically allocated, so we don't
986 * this function creates a new Token and passes a pointer to it
987 * back to the caller. It sets the type and text elements, and
988 * also the mac and next elements to NULL.
990 static Token
*new_Token(Token
* next
, enum pp_token_type type
, char *text
, int txtlen
)
995 if (freeTokens
== NULL
) {
996 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
997 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
998 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
999 freeTokens
[i
].next
= NULL
;
1002 freeTokens
= t
->next
;
1006 if (type
== TOK_WHITESPACE
|| text
== NULL
) {
1010 txtlen
= strlen(text
);
1011 t
->text
= nasm_malloc(1 + txtlen
);
1012 strncpy(t
->text
, text
, txtlen
);
1013 t
->text
[txtlen
] = '\0';
1018 static Token
*delete_Token(Token
* t
)
1020 Token
*next
= t
->next
;
1022 t
->next
= freeTokens
;
1028 * Convert a line of tokens back into text.
1029 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1030 * will be transformed into ..@ctxnum.xxx
1032 static char *detoken(Token
* tlist
, int expand_locals
)
1040 for (t
= tlist
; t
; t
= t
->next
) {
1041 if (t
->type
== TOK_PREPROC_ID
&& t
->text
[1] == '!') {
1042 char *p
= getenv(t
->text
+ 2);
1045 t
->text
= nasm_strdup(p
);
1049 /* Expand local macros here and not during preprocessing */
1050 if (expand_locals
&&
1051 t
->type
== TOK_PREPROC_ID
&& t
->text
&&
1052 t
->text
[0] == '%' && t
->text
[1] == '$') {
1053 Context
*ctx
= get_ctx(t
->text
, false);
1056 char *p
, *q
= t
->text
+ 2;
1058 q
+= strspn(q
, "$");
1059 snprintf(buffer
, sizeof(buffer
), "..@%"PRIu32
".", ctx
->number
);
1060 p
= nasm_strcat(buffer
, q
);
1065 if (t
->type
== TOK_WHITESPACE
) {
1067 } else if (t
->text
) {
1068 len
+= strlen(t
->text
);
1071 p
= line
= nasm_malloc(len
+ 1);
1072 for (t
= tlist
; t
; t
= t
->next
) {
1073 if (t
->type
== TOK_WHITESPACE
) {
1075 } else if (t
->text
) {
1086 * A scanner, suitable for use by the expression evaluator, which
1087 * operates on a line of Tokens. Expects a pointer to a pointer to
1088 * the first token in the line to be passed in as its private_data
1091 * FIX: This really needs to be unified with stdscan.
1093 static int ppscan(void *private_data
, struct tokenval
*tokval
)
1095 Token
**tlineptr
= private_data
;
1097 char ourcopy
[MAX_KEYWORD
+1], *p
, *r
, *s
;
1101 *tlineptr
= tline
? tline
->next
: NULL
;
1103 while (tline
&& (tline
->type
== TOK_WHITESPACE
||
1104 tline
->type
== TOK_COMMENT
));
1107 return tokval
->t_type
= TOKEN_EOS
;
1109 tokval
->t_charptr
= tline
->text
;
1111 if (tline
->text
[0] == '$' && !tline
->text
[1])
1112 return tokval
->t_type
= TOKEN_HERE
;
1113 if (tline
->text
[0] == '$' && tline
->text
[1] == '$' && !tline
->text
[2])
1114 return tokval
->t_type
= TOKEN_BASE
;
1116 if (tline
->type
== TOK_ID
) {
1117 p
= tokval
->t_charptr
= tline
->text
;
1119 tokval
->t_charptr
++;
1120 return tokval
->t_type
= TOKEN_ID
;
1123 for (r
= p
, s
= ourcopy
; *r
; r
++) {
1124 if (r
>= p
+MAX_KEYWORD
)
1125 return tokval
->t_type
= TOKEN_ID
; /* Not a keyword */
1129 /* right, so we have an identifier sitting in temp storage. now,
1130 * is it actually a register or instruction name, or what? */
1131 return nasm_token_hash(ourcopy
, tokval
);
1134 if (tline
->type
== TOK_NUMBER
) {
1136 tokval
->t_integer
= readnum(tline
->text
, &rn_error
);
1138 return tokval
->t_type
= TOKEN_ERRNUM
; /* some malformation occurred */
1139 tokval
->t_charptr
= tline
->text
;
1140 return tokval
->t_type
= TOKEN_NUM
;
1143 if (tline
->type
== TOK_FLOAT
) {
1144 return tokval
->t_type
= TOKEN_FLOAT
;
1147 if (tline
->type
== TOK_STRING
) {
1156 if (l
== 0 || r
[l
- 1] != q
)
1157 return tokval
->t_type
= TOKEN_ERRNUM
;
1158 tokval
->t_integer
= readstrnum(r
, l
- 1, &rn_warn
);
1160 error(ERR_WARNING
| ERR_PASS1
, "character constant too long");
1161 tokval
->t_charptr
= NULL
;
1162 return tokval
->t_type
= TOKEN_NUM
;
1165 if (tline
->type
== TOK_OTHER
) {
1166 if (!strcmp(tline
->text
, "<<"))
1167 return tokval
->t_type
= TOKEN_SHL
;
1168 if (!strcmp(tline
->text
, ">>"))
1169 return tokval
->t_type
= TOKEN_SHR
;
1170 if (!strcmp(tline
->text
, "//"))
1171 return tokval
->t_type
= TOKEN_SDIV
;
1172 if (!strcmp(tline
->text
, "%%"))
1173 return tokval
->t_type
= TOKEN_SMOD
;
1174 if (!strcmp(tline
->text
, "=="))
1175 return tokval
->t_type
= TOKEN_EQ
;
1176 if (!strcmp(tline
->text
, "<>"))
1177 return tokval
->t_type
= TOKEN_NE
;
1178 if (!strcmp(tline
->text
, "!="))
1179 return tokval
->t_type
= TOKEN_NE
;
1180 if (!strcmp(tline
->text
, "<="))
1181 return tokval
->t_type
= TOKEN_LE
;
1182 if (!strcmp(tline
->text
, ">="))
1183 return tokval
->t_type
= TOKEN_GE
;
1184 if (!strcmp(tline
->text
, "&&"))
1185 return tokval
->t_type
= TOKEN_DBL_AND
;
1186 if (!strcmp(tline
->text
, "^^"))
1187 return tokval
->t_type
= TOKEN_DBL_XOR
;
1188 if (!strcmp(tline
->text
, "||"))
1189 return tokval
->t_type
= TOKEN_DBL_OR
;
1193 * We have no other options: just return the first character of
1196 return tokval
->t_type
= tline
->text
[0];
1200 * Compare a string to the name of an existing macro; this is a
1201 * simple wrapper which calls either strcmp or nasm_stricmp
1202 * depending on the value of the `casesense' parameter.
1204 static int mstrcmp(const char *p
, const char *q
, bool casesense
)
1206 return casesense
? strcmp(p
, q
) : nasm_stricmp(p
, q
);
1210 * Return the Context structure associated with a %$ token. Return
1211 * NULL, having _already_ reported an error condition, if the
1212 * context stack isn't deep enough for the supplied number of $
1214 * If all_contexts == true, contexts that enclose current are
1215 * also scanned for such smacro, until it is found; if not -
1216 * only the context that directly results from the number of $'s
1217 * in variable's name.
1219 static Context
*get_ctx(char *name
, bool all_contexts
)
1225 if (!name
|| name
[0] != '%' || name
[1] != '$')
1229 error(ERR_NONFATAL
, "`%s': context stack is empty", name
);
1233 for (i
= strspn(name
+ 2, "$"), ctx
= cstk
; (i
> 0) && ctx
; i
--) {
1235 /* i--; Lino - 02/25/02 */
1238 error(ERR_NONFATAL
, "`%s': context stack is only"
1239 " %d level%s deep", name
, i
- 1, (i
== 2 ? "" : "s"));
1246 /* Search for this smacro in found context */
1247 m
= hash_findix(&ctx
->localmac
, name
);
1249 if (!mstrcmp(m
->name
, name
, m
->casesense
))
1260 * Check to see if a file is already in a string list
1262 static bool in_list(const StrList
*list
, const char *str
)
1265 if (!strcmp(list
->str
, str
))
1273 * Open an include file. This routine must always return a valid
1274 * file pointer if it returns - it's responsible for throwing an
1275 * ERR_FATAL and bombing out completely if not. It should also try
1276 * the include path one by one until it finds the file or reaches
1277 * the end of the path.
1279 static FILE *inc_fopen(const char *file
)
1283 IncPath
*ip
= ipath
;
1284 int len
= strlen(file
);
1285 size_t prefix_len
= 0;
1289 sl
= nasm_malloc(prefix_len
+len
+1+sizeof sl
->next
);
1290 memcpy(sl
->str
, prefix
, prefix_len
);
1291 memcpy(sl
->str
+prefix_len
, file
, len
+1);
1292 fp
= fopen(sl
->str
, "r");
1293 if (fp
&& dephead
&& !in_list(*dephead
, sl
->str
)) {
1296 deptail
= &sl
->next
;
1307 prefix_len
= strlen(prefix
);
1309 /* -MG given and file not found */
1310 if (dephead
&& !in_list(*dephead
, file
)) {
1311 sl
= nasm_malloc(len
+1+sizeof sl
->next
);
1313 strcpy(sl
->str
, file
);
1315 deptail
= &sl
->next
;
1321 error(ERR_FATAL
, "unable to open include file `%s'", file
);
1322 return NULL
; /* never reached - placate compilers */
1326 * Determine if we should warn on defining a single-line macro of
1327 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1328 * return true if _any_ single-line macro of that name is defined.
1329 * Otherwise, will return true if a single-line macro with either
1330 * `nparam' or no parameters is defined.
1332 * If a macro with precisely the right number of parameters is
1333 * defined, or nparam is -1, the address of the definition structure
1334 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1335 * is NULL, no action will be taken regarding its contents, and no
1338 * Note that this is also called with nparam zero to resolve
1341 * If you already know which context macro belongs to, you can pass
1342 * the context pointer as first parameter; if you won't but name begins
1343 * with %$ the context will be automatically computed. If all_contexts
1344 * is true, macro will be searched in outer contexts as well.
1347 smacro_defined(Context
* ctx
, char *name
, int nparam
, SMacro
** defn
,
1350 struct hash_table
*smtbl
;
1354 smtbl
= &ctx
->localmac
;
1355 } else if (name
[0] == '%' && name
[1] == '$') {
1357 ctx
= get_ctx(name
, false);
1359 return false; /* got to return _something_ */
1360 smtbl
= &ctx
->localmac
;
1364 m
= (SMacro
*) hash_findix(smtbl
, name
);
1367 if (!mstrcmp(m
->name
, name
, m
->casesense
&& nocase
) &&
1368 (nparam
<= 0 || m
->nparam
== 0 || nparam
== (int) m
->nparam
)) {
1370 if (nparam
== (int) m
->nparam
|| nparam
== -1)
1384 * Count and mark off the parameters in a multi-line macro call.
1385 * This is called both from within the multi-line macro expansion
1386 * code, and also to mark off the default parameters when provided
1387 * in a %macro definition line.
1389 static void count_mmac_params(Token
* t
, int *nparam
, Token
*** params
)
1391 int paramsize
, brace
;
1393 *nparam
= paramsize
= 0;
1396 if (*nparam
>= paramsize
) {
1397 paramsize
+= PARAM_DELTA
;
1398 *params
= nasm_realloc(*params
, sizeof(**params
) * paramsize
);
1402 if (tok_is_(t
, "{"))
1404 (*params
)[(*nparam
)++] = t
;
1405 while (tok_isnt_(t
, brace
? "}" : ","))
1407 if (t
) { /* got a comma/brace */
1411 * Now we've found the closing brace, look further
1415 if (tok_isnt_(t
, ",")) {
1417 "braces do not enclose all of macro parameter");
1418 while (tok_isnt_(t
, ","))
1422 t
= t
->next
; /* eat the comma */
1429 * Determine whether one of the various `if' conditions is true or
1432 * We must free the tline we get passed.
1434 static bool if_condition(Token
* tline
, enum preproc_token ct
)
1436 enum pp_conditional i
= PP_COND(ct
);
1438 Token
*t
, *tt
, **tptr
, *origline
;
1439 struct tokenval tokval
;
1441 enum pp_token_type needtype
;
1447 j
= false; /* have we matched yet? */
1448 while (cstk
&& tline
) {
1450 if (!tline
|| tline
->type
!= TOK_ID
) {
1452 "`%s' expects context identifiers", pp_directives
[ct
]);
1453 free_tlist(origline
);
1456 if (!nasm_stricmp(tline
->text
, cstk
->name
))
1458 tline
= tline
->next
;
1463 j
= false; /* have we matched yet? */
1466 if (!tline
|| (tline
->type
!= TOK_ID
&&
1467 (tline
->type
!= TOK_PREPROC_ID
||
1468 tline
->text
[1] != '$'))) {
1470 "`%s' expects macro identifiers", pp_directives
[ct
]);
1473 if (smacro_defined(NULL
, tline
->text
, 0, NULL
, true))
1475 tline
= tline
->next
;
1481 tline
= expand_smacro(tline
);
1483 while (tok_isnt_(tt
, ","))
1487 "`%s' expects two comma-separated arguments",
1492 j
= true; /* assume equality unless proved not */
1493 while ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) && tt
) {
1494 if (tt
->type
== TOK_OTHER
&& !strcmp(tt
->text
, ",")) {
1495 error(ERR_NONFATAL
, "`%s': more than one comma on line",
1499 if (t
->type
== TOK_WHITESPACE
) {
1503 if (tt
->type
== TOK_WHITESPACE
) {
1507 if (tt
->type
!= t
->type
) {
1508 j
= false; /* found mismatching tokens */
1511 /* Unify surrounding quotes for strings */
1512 if (t
->type
== TOK_STRING
) {
1513 tt
->text
[0] = t
->text
[0];
1514 tt
->text
[strlen(tt
->text
) - 1] = t
->text
[0];
1516 if (mstrcmp(tt
->text
, t
->text
, i
== PPC_IFIDN
) != 0) {
1517 j
= false; /* found mismatching tokens */
1524 if ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) || tt
)
1525 j
= false; /* trailing gunk on one end or other */
1531 MMacro searching
, *mmac
;
1533 tline
= tline
->next
;
1535 tline
= expand_id(tline
);
1536 if (!tok_type_(tline
, TOK_ID
)) {
1538 "`%s' expects a macro name", pp_directives
[ct
]);
1541 searching
.name
= nasm_strdup(tline
->text
);
1542 searching
.casesense
= true;
1543 searching
.plus
= false;
1544 searching
.nolist
= false;
1545 searching
.in_progress
= 0;
1546 searching
.rep_nest
= NULL
;
1547 searching
.nparam_min
= 0;
1548 searching
.nparam_max
= INT_MAX
;
1549 tline
= expand_smacro(tline
->next
);
1552 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
1554 "`%s' expects a parameter count or nothing",
1557 searching
.nparam_min
= searching
.nparam_max
=
1558 readnum(tline
->text
, &j
);
1561 "unable to parse parameter count `%s'",
1564 if (tline
&& tok_is_(tline
->next
, "-")) {
1565 tline
= tline
->next
->next
;
1566 if (tok_is_(tline
, "*"))
1567 searching
.nparam_max
= INT_MAX
;
1568 else if (!tok_type_(tline
, TOK_NUMBER
))
1570 "`%s' expects a parameter count after `-'",
1573 searching
.nparam_max
= readnum(tline
->text
, &j
);
1576 "unable to parse parameter count `%s'",
1578 if (searching
.nparam_min
> searching
.nparam_max
)
1580 "minimum parameter count exceeds maximum");
1583 if (tline
&& tok_is_(tline
->next
, "+")) {
1584 tline
= tline
->next
;
1585 searching
.plus
= true;
1587 mmac
= (MMacro
*) hash_findix(&mmacros
, searching
.name
);
1589 if (!strcmp(mmac
->name
, searching
.name
) &&
1590 (mmac
->nparam_min
<= searching
.nparam_max
1592 && (searching
.nparam_min
<= mmac
->nparam_max
1599 nasm_free(searching
.name
);
1608 needtype
= TOK_NUMBER
;
1611 needtype
= TOK_STRING
;
1615 t
= tline
= expand_smacro(tline
);
1617 while (tok_type_(t
, TOK_WHITESPACE
) ||
1618 (needtype
== TOK_NUMBER
&&
1619 tok_type_(t
, TOK_OTHER
) &&
1620 (t
->text
[0] == '-' || t
->text
[0] == '+') &&
1624 j
= tok_type_(t
, needtype
);
1628 t
= tline
= expand_smacro(tline
);
1629 while (tok_type_(t
, TOK_WHITESPACE
))
1634 t
= t
->next
; /* Skip the actual token */
1635 while (tok_type_(t
, TOK_WHITESPACE
))
1637 j
= !t
; /* Should be nothing left */
1642 t
= tline
= expand_smacro(tline
);
1643 while (tok_type_(t
, TOK_WHITESPACE
))
1646 j
= !t
; /* Should be empty */
1650 t
= tline
= expand_smacro(tline
);
1652 tokval
.t_type
= TOKEN_INVALID
;
1653 evalresult
= evaluate(ppscan
, tptr
, &tokval
,
1654 NULL
, pass
| CRITICAL
, error
, NULL
);
1659 "trailing garbage after expression ignored");
1660 if (!is_simple(evalresult
)) {
1662 "non-constant value given to `%s'", pp_directives
[ct
]);
1665 j
= reloc_value(evalresult
) != 0;
1670 "preprocessor directive `%s' not yet implemented",
1675 free_tlist(origline
);
1676 return j
^ PP_NEGATIVE(ct
);
1679 free_tlist(origline
);
1684 * Expand macros in a string. Used in %error and %include directives.
1685 * First tokenize the string, apply "expand_smacro" and then de-tokenize back.
1686 * The returned variable should ALWAYS be freed after usage.
1688 void expand_macros_in_string(char **p
)
1690 Token
*line
= tokenize(*p
);
1691 line
= expand_smacro(line
);
1692 *p
= detoken(line
, false);
1696 * Common code for defining an smacro
1698 static bool define_smacro(Context
*ctx
, char *mname
, bool casesense
,
1699 int nparam
, Token
*expansion
)
1701 SMacro
*smac
, **smhead
;
1702 struct hash_table
*smtbl
;
1704 if (smacro_defined(ctx
, mname
, nparam
, &smac
, casesense
)) {
1707 "single-line macro `%s' defined both with and"
1708 " without parameters", mname
);
1710 /* Some instances of the old code considered this a failure,
1711 some others didn't. What is the right thing to do here? */
1712 free_tlist(expansion
);
1713 return false; /* Failure */
1716 * We're redefining, so we have to take over an
1717 * existing SMacro structure. This means freeing
1718 * what was already in it.
1720 nasm_free(smac
->name
);
1721 free_tlist(smac
->expansion
);
1724 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1725 smhead
= (SMacro
**) hash_findi_add(smtbl
, mname
);
1726 smac
= nasm_malloc(sizeof(SMacro
));
1727 smac
->next
= *smhead
;
1730 smac
->name
= nasm_strdup(mname
);
1731 smac
->casesense
= casesense
;
1732 smac
->nparam
= nparam
;
1733 smac
->expansion
= expansion
;
1734 smac
->in_progress
= false;
1735 return true; /* Success */
1739 * Undefine an smacro
1741 static void undef_smacro(Context
*ctx
, const char *mname
)
1743 SMacro
**smhead
, *s
, **sp
;
1744 struct hash_table
*smtbl
;
1746 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
1747 smhead
= (SMacro
**)hash_findi(smtbl
, mname
, NULL
);
1751 * We now have a macro name... go hunt for it.
1754 while ((s
= *sp
) != NULL
) {
1755 if (!mstrcmp(s
->name
, mname
, s
->casesense
)) {
1758 free_tlist(s
->expansion
);
1768 * Decode a size directive
1770 static int parse_size(const char *str
) {
1771 static const char *size_names
[] =
1772 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
1773 static const int sizes
[] =
1774 { 0, 1, 4, 16, 8, 10, 2, 32 };
1776 return sizes
[bsii(str
, size_names
, elements(size_names
))+1];
1780 * find and process preprocessor directive in passed line
1781 * Find out if a line contains a preprocessor directive, and deal
1784 * If a directive _is_ found, it is the responsibility of this routine
1785 * (and not the caller) to free_tlist() the line.
1787 * @param tline a pointer to the current tokeninzed line linked list
1788 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
1791 static int do_directive(Token
* tline
)
1793 enum preproc_token i
;
1805 MMacro
*mmac
, **mmhead
;
1806 Token
*t
, *tt
, *param_start
, *macro_start
, *last
, **tptr
, *origline
;
1808 struct tokenval tokval
;
1810 MMacro
*tmp_defining
; /* Used when manipulating rep_nest */
1816 if (!tok_type_(tline
, TOK_PREPROC_ID
) ||
1817 (tline
->text
[1] == '%' || tline
->text
[1] == '$'
1818 || tline
->text
[1] == '!'))
1819 return NO_DIRECTIVE_FOUND
;
1821 i
= pp_token_hash(tline
->text
);
1824 * If we're in a non-emitting branch of a condition construct,
1825 * or walking to the end of an already terminated %rep block,
1826 * we should ignore all directives except for condition
1829 if (((istk
->conds
&& !emitting(istk
->conds
->state
)) ||
1830 (istk
->mstk
&& !istk
->mstk
->in_progress
)) && !is_condition(i
)) {
1831 return NO_DIRECTIVE_FOUND
;
1835 * If we're defining a macro or reading a %rep block, we should
1836 * ignore all directives except for %macro/%imacro (which
1837 * generate an error), %endm/%endmacro, and (only if we're in a
1838 * %rep block) %endrep. If we're in a %rep block, another %rep
1839 * causes an error, so should be let through.
1841 if (defining
&& i
!= PP_MACRO
&& i
!= PP_IMACRO
&&
1842 i
!= PP_ENDMACRO
&& i
!= PP_ENDM
&&
1843 (defining
->name
|| (i
!= PP_ENDREP
&& i
!= PP_REP
))) {
1844 return NO_DIRECTIVE_FOUND
;
1849 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
1851 return NO_DIRECTIVE_FOUND
; /* didn't get it */
1854 /* Directive to tell NASM what the default stack size is. The
1855 * default is for a 16-bit stack, and this can be overriden with
1857 * the following form:
1859 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1861 tline
= tline
->next
;
1862 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1863 tline
= tline
->next
;
1864 if (!tline
|| tline
->type
!= TOK_ID
) {
1865 error(ERR_NONFATAL
, "`%%stacksize' missing size parameter");
1866 free_tlist(origline
);
1867 return DIRECTIVE_FOUND
;
1869 if (nasm_stricmp(tline
->text
, "flat") == 0) {
1870 /* All subsequent ARG directives are for a 32-bit stack */
1872 StackPointer
= "ebp";
1875 } else if (nasm_stricmp(tline
->text
, "flat64") == 0) {
1876 /* All subsequent ARG directives are for a 64-bit stack */
1878 StackPointer
= "rbp";
1881 } else if (nasm_stricmp(tline
->text
, "large") == 0) {
1882 /* All subsequent ARG directives are for a 16-bit stack,
1883 * far function call.
1886 StackPointer
= "bp";
1889 } else if (nasm_stricmp(tline
->text
, "small") == 0) {
1890 /* All subsequent ARG directives are for a 16-bit stack,
1891 * far function call. We don't support near functions.
1894 StackPointer
= "bp";
1898 error(ERR_NONFATAL
, "`%%stacksize' invalid size type");
1899 free_tlist(origline
);
1900 return DIRECTIVE_FOUND
;
1902 free_tlist(origline
);
1903 return DIRECTIVE_FOUND
;
1906 /* TASM like ARG directive to define arguments to functions, in
1907 * the following form:
1909 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1913 char *arg
, directive
[256];
1914 int size
= StackSize
;
1916 /* Find the argument name */
1917 tline
= tline
->next
;
1918 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1919 tline
= tline
->next
;
1920 if (!tline
|| tline
->type
!= TOK_ID
) {
1921 error(ERR_NONFATAL
, "`%%arg' missing argument parameter");
1922 free_tlist(origline
);
1923 return DIRECTIVE_FOUND
;
1927 /* Find the argument size type */
1928 tline
= tline
->next
;
1929 if (!tline
|| tline
->type
!= TOK_OTHER
1930 || tline
->text
[0] != ':') {
1932 "Syntax error processing `%%arg' directive");
1933 free_tlist(origline
);
1934 return DIRECTIVE_FOUND
;
1936 tline
= tline
->next
;
1937 if (!tline
|| tline
->type
!= TOK_ID
) {
1938 error(ERR_NONFATAL
, "`%%arg' missing size type parameter");
1939 free_tlist(origline
);
1940 return DIRECTIVE_FOUND
;
1943 /* Allow macro expansion of type parameter */
1944 tt
= tokenize(tline
->text
);
1945 tt
= expand_smacro(tt
);
1946 size
= parse_size(tt
->text
);
1949 "Invalid size type for `%%arg' missing directive");
1951 free_tlist(origline
);
1952 return DIRECTIVE_FOUND
;
1956 /* Round up to even stack slots */
1957 size
= (size
+StackSize
-1) & ~(StackSize
-1);
1959 /* Now define the macro for the argument */
1960 snprintf(directive
, sizeof(directive
), "%%define %s (%s+%d)",
1961 arg
, StackPointer
, offset
);
1962 do_directive(tokenize(directive
));
1965 /* Move to the next argument in the list */
1966 tline
= tline
->next
;
1967 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1968 tline
= tline
->next
;
1969 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
1971 free_tlist(origline
);
1972 return DIRECTIVE_FOUND
;
1975 /* TASM like LOCAL directive to define local variables for a
1976 * function, in the following form:
1978 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
1980 * The '= LocalSize' at the end is ignored by NASM, but is
1981 * required by TASM to define the local parameter size (and used
1982 * by the TASM macro package).
1984 offset
= LocalOffset
;
1986 char *local
, directive
[256];
1987 int size
= StackSize
;
1989 /* Find the argument name */
1990 tline
= tline
->next
;
1991 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1992 tline
= tline
->next
;
1993 if (!tline
|| tline
->type
!= TOK_ID
) {
1995 "`%%local' missing argument parameter");
1996 free_tlist(origline
);
1997 return DIRECTIVE_FOUND
;
1999 local
= tline
->text
;
2001 /* Find the argument size type */
2002 tline
= tline
->next
;
2003 if (!tline
|| tline
->type
!= TOK_OTHER
2004 || tline
->text
[0] != ':') {
2006 "Syntax error processing `%%local' directive");
2007 free_tlist(origline
);
2008 return DIRECTIVE_FOUND
;
2010 tline
= tline
->next
;
2011 if (!tline
|| tline
->type
!= TOK_ID
) {
2013 "`%%local' missing size type parameter");
2014 free_tlist(origline
);
2015 return DIRECTIVE_FOUND
;
2018 /* Allow macro expansion of type parameter */
2019 tt
= tokenize(tline
->text
);
2020 tt
= expand_smacro(tt
);
2021 size
= parse_size(tt
->text
);
2024 "Invalid size type for `%%local' missing directive");
2026 free_tlist(origline
);
2027 return DIRECTIVE_FOUND
;
2031 /* Round up to even stack slots */
2032 size
= (size
+StackSize
-1) & ~(StackSize
-1);
2034 offset
+= size
; /* Negative offset, increment before */
2036 /* Now define the macro for the argument */
2037 snprintf(directive
, sizeof(directive
), "%%define %s (%s-%d)",
2038 local
, StackPointer
, offset
);
2039 do_directive(tokenize(directive
));
2041 /* Now define the assign to setup the enter_c macro correctly */
2042 snprintf(directive
, sizeof(directive
),
2043 "%%assign %%$localsize %%$localsize+%d", size
);
2044 do_directive(tokenize(directive
));
2046 /* Move to the next argument in the list */
2047 tline
= tline
->next
;
2048 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2049 tline
= tline
->next
;
2050 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2051 LocalOffset
= offset
;
2052 free_tlist(origline
);
2053 return DIRECTIVE_FOUND
;
2057 error(ERR_WARNING
, "trailing garbage after `%%clear' ignored");
2060 free_tlist(origline
);
2061 return DIRECTIVE_FOUND
;
2064 tline
= tline
->next
;
2066 if (!tline
|| (tline
->type
!= TOK_STRING
&&
2067 tline
->type
!= TOK_INTERNAL_STRING
)) {
2068 error(ERR_NONFATAL
, "`%%include' expects a file name");
2069 free_tlist(origline
);
2070 return DIRECTIVE_FOUND
; /* but we did _something_ */
2074 "trailing garbage after `%%include' ignored");
2075 if (tline
->type
!= TOK_INTERNAL_STRING
) {
2076 p
= tline
->text
+ 1; /* point past the quote to the name */
2077 p
[strlen(p
) - 1] = '\0'; /* remove the trailing quote */
2079 p
= tline
->text
; /* internal_string is easier */
2080 expand_macros_in_string(&p
);
2081 inc
= nasm_malloc(sizeof(Include
));
2084 inc
->fp
= inc_fopen(p
);
2085 if (!inc
->fp
&& pass
== 0) {
2086 /* -MG given but file not found */
2089 inc
->fname
= src_set_fname(p
);
2090 inc
->lineno
= src_set_linnum(0);
2092 inc
->expansion
= NULL
;
2095 list
->uplevel(LIST_INCLUDE
);
2097 free_tlist(origline
);
2098 return DIRECTIVE_FOUND
;
2101 tline
= tline
->next
;
2103 tline
= expand_id(tline
);
2104 if (!tok_type_(tline
, TOK_ID
)) {
2105 error(ERR_NONFATAL
, "`%%push' expects a context identifier");
2106 free_tlist(origline
);
2107 return DIRECTIVE_FOUND
; /* but we did _something_ */
2110 error(ERR_WARNING
, "trailing garbage after `%%push' ignored");
2111 ctx
= nasm_malloc(sizeof(Context
));
2113 hash_init(&ctx
->localmac
, HASH_SMALL
);
2114 ctx
->name
= nasm_strdup(tline
->text
);
2115 ctx
->number
= unique
++;
2117 free_tlist(origline
);
2121 tline
= tline
->next
;
2123 tline
= expand_id(tline
);
2124 if (!tok_type_(tline
, TOK_ID
)) {
2125 error(ERR_NONFATAL
, "`%%repl' expects a context identifier");
2126 free_tlist(origline
);
2127 return DIRECTIVE_FOUND
; /* but we did _something_ */
2130 error(ERR_WARNING
, "trailing garbage after `%%repl' ignored");
2132 error(ERR_NONFATAL
, "`%%repl': context stack is empty");
2134 nasm_free(cstk
->name
);
2135 cstk
->name
= nasm_strdup(tline
->text
);
2137 free_tlist(origline
);
2142 error(ERR_WARNING
, "trailing garbage after `%%pop' ignored");
2144 error(ERR_NONFATAL
, "`%%pop': context stack is already empty");
2147 free_tlist(origline
);
2151 tline
->next
= expand_smacro(tline
->next
);
2152 tline
= tline
->next
;
2154 if (tok_type_(tline
, TOK_STRING
)) {
2155 p
= tline
->text
+ 1; /* point past the quote to the name */
2156 p
[strlen(p
) - 1] = '\0'; /* remove the trailing quote */
2157 expand_macros_in_string(&p
);
2158 error(ERR_NONFATAL
, "%s", p
);
2161 p
= detoken(tline
, false);
2162 error(ERR_WARNING
, "%s", p
);
2165 free_tlist(origline
);
2169 if (istk
->conds
&& !emitting(istk
->conds
->state
))
2172 j
= if_condition(tline
->next
, i
);
2173 tline
->next
= NULL
; /* it got freed */
2174 j
= j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2176 cond
= nasm_malloc(sizeof(Cond
));
2177 cond
->next
= istk
->conds
;
2180 free_tlist(origline
);
2181 return DIRECTIVE_FOUND
;
2185 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2186 if (emitting(istk
->conds
->state
)
2187 || istk
->conds
->state
== COND_NEVER
)
2188 istk
->conds
->state
= COND_NEVER
;
2191 * IMPORTANT: In the case of %if, we will already have
2192 * called expand_mmac_params(); however, if we're
2193 * processing an %elif we must have been in a
2194 * non-emitting mode, which would have inhibited
2195 * the normal invocation of expand_mmac_params(). Therefore,
2196 * we have to do it explicitly here.
2198 j
= if_condition(expand_mmac_params(tline
->next
), i
);
2199 tline
->next
= NULL
; /* it got freed */
2200 istk
->conds
->state
=
2201 j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2203 free_tlist(origline
);
2204 return DIRECTIVE_FOUND
;
2208 error(ERR_WARNING
, "trailing garbage after `%%else' ignored");
2210 error(ERR_FATAL
, "`%%else': no matching `%%if'");
2211 if (emitting(istk
->conds
->state
)
2212 || istk
->conds
->state
== COND_NEVER
)
2213 istk
->conds
->state
= COND_ELSE_FALSE
;
2215 istk
->conds
->state
= COND_ELSE_TRUE
;
2216 free_tlist(origline
);
2217 return DIRECTIVE_FOUND
;
2221 error(ERR_WARNING
, "trailing garbage after `%%endif' ignored");
2223 error(ERR_FATAL
, "`%%endif': no matching `%%if'");
2225 istk
->conds
= cond
->next
;
2227 free_tlist(origline
);
2228 return DIRECTIVE_FOUND
;
2234 "`%%%smacro': already defining a macro",
2235 (i
== PP_IMACRO
? "i" : ""));
2236 tline
= tline
->next
;
2238 tline
= expand_id(tline
);
2239 if (!tok_type_(tline
, TOK_ID
)) {
2241 "`%%%smacro' expects a macro name",
2242 (i
== PP_IMACRO
? "i" : ""));
2243 return DIRECTIVE_FOUND
;
2245 defining
= nasm_malloc(sizeof(MMacro
));
2246 defining
->name
= nasm_strdup(tline
->text
);
2247 defining
->casesense
= (i
== PP_MACRO
);
2248 defining
->plus
= false;
2249 defining
->nolist
= false;
2250 defining
->in_progress
= 0;
2251 defining
->rep_nest
= NULL
;
2252 tline
= expand_smacro(tline
->next
);
2254 if (!tok_type_(tline
, TOK_NUMBER
)) {
2256 "`%%%smacro' expects a parameter count",
2257 (i
== PP_IMACRO
? "i" : ""));
2258 defining
->nparam_min
= defining
->nparam_max
= 0;
2260 defining
->nparam_min
= defining
->nparam_max
=
2261 readnum(tline
->text
, &err
);
2264 "unable to parse parameter count `%s'", tline
->text
);
2266 if (tline
&& tok_is_(tline
->next
, "-")) {
2267 tline
= tline
->next
->next
;
2268 if (tok_is_(tline
, "*"))
2269 defining
->nparam_max
= INT_MAX
;
2270 else if (!tok_type_(tline
, TOK_NUMBER
))
2272 "`%%%smacro' expects a parameter count after `-'",
2273 (i
== PP_IMACRO
? "i" : ""));
2275 defining
->nparam_max
= readnum(tline
->text
, &err
);
2278 "unable to parse parameter count `%s'",
2280 if (defining
->nparam_min
> defining
->nparam_max
)
2282 "minimum parameter count exceeds maximum");
2285 if (tline
&& tok_is_(tline
->next
, "+")) {
2286 tline
= tline
->next
;
2287 defining
->plus
= true;
2289 if (tline
&& tok_type_(tline
->next
, TOK_ID
) &&
2290 !nasm_stricmp(tline
->next
->text
, ".nolist")) {
2291 tline
= tline
->next
;
2292 defining
->nolist
= true;
2294 mmac
= (MMacro
*) hash_findix(&mmacros
, defining
->name
);
2296 if (!strcmp(mmac
->name
, defining
->name
) &&
2297 (mmac
->nparam_min
<= defining
->nparam_max
2299 && (defining
->nparam_min
<= mmac
->nparam_max
2302 "redefining multi-line macro `%s'", defining
->name
);
2308 * Handle default parameters.
2310 if (tline
&& tline
->next
) {
2311 defining
->dlist
= tline
->next
;
2313 count_mmac_params(defining
->dlist
, &defining
->ndefs
,
2314 &defining
->defaults
);
2316 defining
->dlist
= NULL
;
2317 defining
->defaults
= NULL
;
2319 defining
->expansion
= NULL
;
2320 free_tlist(origline
);
2321 return DIRECTIVE_FOUND
;
2326 error(ERR_NONFATAL
, "`%s': not defining a macro", tline
->text
);
2327 return DIRECTIVE_FOUND
;
2329 mmhead
= (MMacro
**) hash_findi_add(&mmacros
, defining
->name
);
2330 defining
->next
= *mmhead
;
2333 free_tlist(origline
);
2334 return DIRECTIVE_FOUND
;
2337 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
2338 tline
= tline
->next
;
2339 if (tline
->next
== NULL
) {
2340 free_tlist(origline
);
2341 error(ERR_NONFATAL
, "`%%rotate' missing rotate count");
2342 return DIRECTIVE_FOUND
;
2344 t
= expand_smacro(tline
->next
);
2346 free_tlist(origline
);
2349 tokval
.t_type
= TOKEN_INVALID
;
2351 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2354 return DIRECTIVE_FOUND
;
2357 "trailing garbage after expression ignored");
2358 if (!is_simple(evalresult
)) {
2359 error(ERR_NONFATAL
, "non-constant value given to `%%rotate'");
2360 return DIRECTIVE_FOUND
;
2363 while (mmac
&& !mmac
->name
) /* avoid mistaking %reps for macros */
2364 mmac
= mmac
->next_active
;
2366 error(ERR_NONFATAL
, "`%%rotate' invoked outside a macro call");
2367 } else if (mmac
->nparam
== 0) {
2369 "`%%rotate' invoked within macro without parameters");
2371 int rotate
= mmac
->rotate
+ reloc_value(evalresult
);
2373 rotate
%= (int)mmac
->nparam
;
2375 rotate
+= mmac
->nparam
;
2377 mmac
->rotate
= rotate
;
2379 return DIRECTIVE_FOUND
;
2384 tline
= tline
->next
;
2385 } while (tok_type_(tline
, TOK_WHITESPACE
));
2387 if (tok_type_(tline
, TOK_ID
) &&
2388 nasm_stricmp(tline
->text
, ".nolist") == 0) {
2391 tline
= tline
->next
;
2392 } while (tok_type_(tline
, TOK_WHITESPACE
));
2396 t
= expand_smacro(tline
);
2398 tokval
.t_type
= TOKEN_INVALID
;
2400 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2402 free_tlist(origline
);
2403 return DIRECTIVE_FOUND
;
2407 "trailing garbage after expression ignored");
2408 if (!is_simple(evalresult
)) {
2409 error(ERR_NONFATAL
, "non-constant value given to `%%rep'");
2410 return DIRECTIVE_FOUND
;
2412 count
= reloc_value(evalresult
) + 1;
2414 error(ERR_NONFATAL
, "`%%rep' expects a repeat count");
2417 free_tlist(origline
);
2419 tmp_defining
= defining
;
2420 defining
= nasm_malloc(sizeof(MMacro
));
2421 defining
->name
= NULL
; /* flags this macro as a %rep block */
2422 defining
->casesense
= false;
2423 defining
->plus
= false;
2424 defining
->nolist
= nolist
;
2425 defining
->in_progress
= count
;
2426 defining
->nparam_min
= defining
->nparam_max
= 0;
2427 defining
->defaults
= NULL
;
2428 defining
->dlist
= NULL
;
2429 defining
->expansion
= NULL
;
2430 defining
->next_active
= istk
->mstk
;
2431 defining
->rep_nest
= tmp_defining
;
2432 return DIRECTIVE_FOUND
;
2435 if (!defining
|| defining
->name
) {
2436 error(ERR_NONFATAL
, "`%%endrep': no matching `%%rep'");
2437 return DIRECTIVE_FOUND
;
2441 * Now we have a "macro" defined - although it has no name
2442 * and we won't be entering it in the hash tables - we must
2443 * push a macro-end marker for it on to istk->expansion.
2444 * After that, it will take care of propagating itself (a
2445 * macro-end marker line for a macro which is really a %rep
2446 * block will cause the macro to be re-expanded, complete
2447 * with another macro-end marker to ensure the process
2448 * continues) until the whole expansion is forcibly removed
2449 * from istk->expansion by a %exitrep.
2451 l
= nasm_malloc(sizeof(Line
));
2452 l
->next
= istk
->expansion
;
2453 l
->finishes
= defining
;
2455 istk
->expansion
= l
;
2457 istk
->mstk
= defining
;
2459 list
->uplevel(defining
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
2460 tmp_defining
= defining
;
2461 defining
= defining
->rep_nest
;
2462 free_tlist(origline
);
2463 return DIRECTIVE_FOUND
;
2467 * We must search along istk->expansion until we hit a
2468 * macro-end marker for a macro with no name. Then we set
2469 * its `in_progress' flag to 0.
2471 for (l
= istk
->expansion
; l
; l
= l
->next
)
2472 if (l
->finishes
&& !l
->finishes
->name
)
2476 l
->finishes
->in_progress
= 0;
2478 error(ERR_NONFATAL
, "`%%exitrep' not within `%%rep' block");
2479 free_tlist(origline
);
2480 return DIRECTIVE_FOUND
;
2486 casesense
= (i
== PP_DEFINE
|| i
== PP_XDEFINE
);
2488 tline
= tline
->next
;
2490 tline
= expand_id(tline
);
2491 if (!tline
|| (tline
->type
!= TOK_ID
&&
2492 (tline
->type
!= TOK_PREPROC_ID
||
2493 tline
->text
[1] != '$'))) {
2494 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
2496 free_tlist(origline
);
2497 return DIRECTIVE_FOUND
;
2500 ctx
= get_ctx(tline
->text
, false);
2502 mname
= tline
->text
;
2504 param_start
= tline
= tline
->next
;
2507 /* Expand the macro definition now for %xdefine and %ixdefine */
2508 if ((i
== PP_XDEFINE
) || (i
== PP_IXDEFINE
))
2509 tline
= expand_smacro(tline
);
2511 if (tok_is_(tline
, "(")) {
2513 * This macro has parameters.
2516 tline
= tline
->next
;
2520 error(ERR_NONFATAL
, "parameter identifier expected");
2521 free_tlist(origline
);
2522 return DIRECTIVE_FOUND
;
2524 if (tline
->type
!= TOK_ID
) {
2526 "`%s': parameter identifier expected",
2528 free_tlist(origline
);
2529 return DIRECTIVE_FOUND
;
2531 tline
->type
= TOK_SMAC_PARAM
+ nparam
++;
2532 tline
= tline
->next
;
2534 if (tok_is_(tline
, ",")) {
2535 tline
= tline
->next
;
2538 if (!tok_is_(tline
, ")")) {
2540 "`)' expected to terminate macro template");
2541 free_tlist(origline
);
2542 return DIRECTIVE_FOUND
;
2547 tline
= tline
->next
;
2549 if (tok_type_(tline
, TOK_WHITESPACE
))
2550 last
= tline
, tline
= tline
->next
;
2555 if (t
->type
== TOK_ID
) {
2556 for (tt
= param_start
; tt
; tt
= tt
->next
)
2557 if (tt
->type
>= TOK_SMAC_PARAM
&&
2558 !strcmp(tt
->text
, t
->text
))
2562 t
->next
= macro_start
;
2567 * Good. We now have a macro name, a parameter count, and a
2568 * token list (in reverse order) for an expansion. We ought
2569 * to be OK just to create an SMacro, store it, and let
2570 * free_tlist have the rest of the line (which we have
2571 * carefully re-terminated after chopping off the expansion
2574 define_smacro(ctx
, mname
, casesense
, nparam
, macro_start
);
2575 free_tlist(origline
);
2576 return DIRECTIVE_FOUND
;
2579 tline
= tline
->next
;
2581 tline
= expand_id(tline
);
2582 if (!tline
|| (tline
->type
!= TOK_ID
&&
2583 (tline
->type
!= TOK_PREPROC_ID
||
2584 tline
->text
[1] != '$'))) {
2585 error(ERR_NONFATAL
, "`%%undef' expects a macro identifier");
2586 free_tlist(origline
);
2587 return DIRECTIVE_FOUND
;
2591 "trailing garbage after macro name ignored");
2594 /* Find the context that symbol belongs to */
2595 ctx
= get_ctx(tline
->text
, false);
2596 undef_smacro(ctx
, tline
->text
);
2597 free_tlist(origline
);
2598 return DIRECTIVE_FOUND
;
2603 tline
= tline
->next
;
2605 tline
= expand_id(tline
);
2606 if (!tline
|| (tline
->type
!= TOK_ID
&&
2607 (tline
->type
!= TOK_PREPROC_ID
||
2608 tline
->text
[1] != '$'))) {
2610 "`%%strlen' expects a macro identifier as first parameter");
2611 free_tlist(origline
);
2612 return DIRECTIVE_FOUND
;
2614 ctx
= get_ctx(tline
->text
, false);
2616 mname
= tline
->text
;
2618 tline
= expand_smacro(tline
->next
);
2622 while (tok_type_(t
, TOK_WHITESPACE
))
2624 /* t should now point to the string */
2625 if (t
->type
!= TOK_STRING
) {
2627 "`%%strlen` requires string as second parameter");
2629 free_tlist(origline
);
2630 return DIRECTIVE_FOUND
;
2633 macro_start
= nasm_malloc(sizeof(*macro_start
));
2634 macro_start
->next
= NULL
;
2635 make_tok_num(macro_start
, strlen(t
->text
) - 2);
2636 macro_start
->mac
= NULL
;
2639 * We now have a macro name, an implicit parameter count of
2640 * zero, and a numeric token to use as an expansion. Create
2641 * and store an SMacro.
2643 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2645 free_tlist(origline
);
2646 return DIRECTIVE_FOUND
;
2651 tline
= tline
->next
;
2653 tline
= expand_id(tline
);
2654 if (!tline
|| (tline
->type
!= TOK_ID
&&
2655 (tline
->type
!= TOK_PREPROC_ID
||
2656 tline
->text
[1] != '$'))) {
2658 "`%%substr' expects a macro identifier as first parameter");
2659 free_tlist(origline
);
2660 return DIRECTIVE_FOUND
;
2662 ctx
= get_ctx(tline
->text
, false);
2664 mname
= tline
->text
;
2666 tline
= expand_smacro(tline
->next
);
2670 while (tok_type_(t
, TOK_WHITESPACE
))
2673 /* t should now point to the string */
2674 if (t
->type
!= TOK_STRING
) {
2676 "`%%substr` requires string as second parameter");
2678 free_tlist(origline
);
2679 return DIRECTIVE_FOUND
;
2684 tokval
.t_type
= TOKEN_INVALID
;
2686 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2689 free_tlist(origline
);
2690 return DIRECTIVE_FOUND
;
2692 if (!is_simple(evalresult
)) {
2693 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
2695 free_tlist(origline
);
2696 return DIRECTIVE_FOUND
;
2699 macro_start
= nasm_malloc(sizeof(*macro_start
));
2700 macro_start
->next
= NULL
;
2701 macro_start
->text
= nasm_strdup("'''");
2702 if (evalresult
->value
> 0
2703 && evalresult
->value
< (int) strlen(t
->text
) - 1) {
2704 macro_start
->text
[1] = t
->text
[evalresult
->value
];
2706 macro_start
->text
[2] = '\0';
2708 macro_start
->type
= TOK_STRING
;
2709 macro_start
->mac
= NULL
;
2712 * We now have a macro name, an implicit parameter count of
2713 * zero, and a numeric token to use as an expansion. Create
2714 * and store an SMacro.
2716 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2718 free_tlist(origline
);
2719 return DIRECTIVE_FOUND
;
2723 casesense
= (i
== PP_ASSIGN
);
2725 tline
= tline
->next
;
2727 tline
= expand_id(tline
);
2728 if (!tline
|| (tline
->type
!= TOK_ID
&&
2729 (tline
->type
!= TOK_PREPROC_ID
||
2730 tline
->text
[1] != '$'))) {
2732 "`%%%sassign' expects a macro identifier",
2733 (i
== PP_IASSIGN
? "i" : ""));
2734 free_tlist(origline
);
2735 return DIRECTIVE_FOUND
;
2737 ctx
= get_ctx(tline
->text
, false);
2739 mname
= tline
->text
;
2741 tline
= expand_smacro(tline
->next
);
2746 tokval
.t_type
= TOKEN_INVALID
;
2748 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2751 free_tlist(origline
);
2752 return DIRECTIVE_FOUND
;
2757 "trailing garbage after expression ignored");
2759 if (!is_simple(evalresult
)) {
2761 "non-constant value given to `%%%sassign'",
2762 (i
== PP_IASSIGN
? "i" : ""));
2763 free_tlist(origline
);
2764 return DIRECTIVE_FOUND
;
2767 macro_start
= nasm_malloc(sizeof(*macro_start
));
2768 macro_start
->next
= NULL
;
2769 make_tok_num(macro_start
, reloc_value(evalresult
));
2770 macro_start
->mac
= NULL
;
2773 * We now have a macro name, an implicit parameter count of
2774 * zero, and a numeric token to use as an expansion. Create
2775 * and store an SMacro.
2777 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
2778 free_tlist(origline
);
2779 return DIRECTIVE_FOUND
;
2783 * Syntax is `%line nnn[+mmm] [filename]'
2785 tline
= tline
->next
;
2787 if (!tok_type_(tline
, TOK_NUMBER
)) {
2788 error(ERR_NONFATAL
, "`%%line' expects line number");
2789 free_tlist(origline
);
2790 return DIRECTIVE_FOUND
;
2792 k
= readnum(tline
->text
, &err
);
2794 tline
= tline
->next
;
2795 if (tok_is_(tline
, "+")) {
2796 tline
= tline
->next
;
2797 if (!tok_type_(tline
, TOK_NUMBER
)) {
2798 error(ERR_NONFATAL
, "`%%line' expects line increment");
2799 free_tlist(origline
);
2800 return DIRECTIVE_FOUND
;
2802 m
= readnum(tline
->text
, &err
);
2803 tline
= tline
->next
;
2809 nasm_free(src_set_fname(detoken(tline
, false)));
2811 free_tlist(origline
);
2812 return DIRECTIVE_FOUND
;
2816 "preprocessor directive `%s' not yet implemented",
2820 return DIRECTIVE_FOUND
;
2824 * Ensure that a macro parameter contains a condition code and
2825 * nothing else. Return the condition code index if so, or -1
2828 static int find_cc(Token
* t
)
2834 return -1; /* Probably a %+ without a space */
2837 if (t
->type
!= TOK_ID
)
2841 if (tt
&& (tt
->type
!= TOK_OTHER
|| strcmp(tt
->text
, ",")))
2845 j
= elements(conditions
);
2848 m
= nasm_stricmp(t
->text
, conditions
[k
]);
2864 * Expand MMacro-local things: parameter references (%0, %n, %+n,
2865 * %-n) and MMacro-local identifiers (%%foo).
2867 static Token
*expand_mmac_params(Token
* tline
)
2869 Token
*t
, *tt
, **tail
, *thead
;
2875 if (tline
->type
== TOK_PREPROC_ID
&&
2876 (((tline
->text
[1] == '+' || tline
->text
[1] == '-')
2877 && tline
->text
[2]) || tline
->text
[1] == '%'
2878 || (tline
->text
[1] >= '0' && tline
->text
[1] <= '9'))) {
2880 int type
= 0, cc
; /* type = 0 to placate optimisers */
2887 tline
= tline
->next
;
2890 while (mac
&& !mac
->name
) /* avoid mistaking %reps for macros */
2891 mac
= mac
->next_active
;
2893 error(ERR_NONFATAL
, "`%s': not in a macro call", t
->text
);
2895 switch (t
->text
[1]) {
2897 * We have to make a substitution of one of the
2898 * forms %1, %-1, %+1, %%foo, %0.
2902 snprintf(tmpbuf
, sizeof(tmpbuf
), "%d", mac
->nparam
);
2903 text
= nasm_strdup(tmpbuf
);
2907 snprintf(tmpbuf
, sizeof(tmpbuf
), "..@%"PRIu64
".",
2909 text
= nasm_strcat(tmpbuf
, t
->text
+ 2);
2912 n
= atoi(t
->text
+ 2) - 1;
2913 if (n
>= mac
->nparam
)
2916 if (mac
->nparam
> 1)
2917 n
= (n
+ mac
->rotate
) % mac
->nparam
;
2918 tt
= mac
->params
[n
];
2923 "macro parameter %d is not a condition code",
2928 if (inverse_ccs
[cc
] == -1) {
2930 "condition code `%s' is not invertible",
2935 nasm_strdup(conditions
[inverse_ccs
[cc
]]);
2939 n
= atoi(t
->text
+ 2) - 1;
2940 if (n
>= mac
->nparam
)
2943 if (mac
->nparam
> 1)
2944 n
= (n
+ mac
->rotate
) % mac
->nparam
;
2945 tt
= mac
->params
[n
];
2950 "macro parameter %d is not a condition code",
2955 text
= nasm_strdup(conditions
[cc
]);
2959 n
= atoi(t
->text
+ 1) - 1;
2960 if (n
>= mac
->nparam
)
2963 if (mac
->nparam
> 1)
2964 n
= (n
+ mac
->rotate
) % mac
->nparam
;
2965 tt
= mac
->params
[n
];
2968 for (i
= 0; i
< mac
->paramlen
[n
]; i
++) {
2969 *tail
= new_Token(NULL
, tt
->type
, tt
->text
, 0);
2970 tail
= &(*tail
)->next
;
2974 text
= NULL
; /* we've done it here */
2990 tline
= tline
->next
;
2997 for (; t
&& (tt
= t
->next
) != NULL
; t
= t
->next
)
2999 case TOK_WHITESPACE
:
3000 if (tt
->type
== TOK_WHITESPACE
) {
3001 t
->next
= delete_Token(tt
);
3005 if (tt
->type
== TOK_ID
|| tt
->type
== TOK_NUMBER
) {
3006 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3009 t
->next
= delete_Token(tt
);
3013 if (tt
->type
== TOK_NUMBER
) {
3014 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3017 t
->next
= delete_Token(tt
);
3028 * Expand all single-line macro calls made in the given line.
3029 * Return the expanded version of the line. The original is deemed
3030 * to be destroyed in the process. (In reality we'll just move
3031 * Tokens from input to output a lot of the time, rather than
3032 * actually bothering to destroy and replicate.)
3034 #define DEADMAN_LIMIT (1 << 20)
3036 static Token
*expand_smacro(Token
* tline
)
3038 Token
*t
, *tt
, *mstart
, **tail
, *thead
;
3039 struct hash_table
*smtbl
;
3040 SMacro
*head
= NULL
, *m
;
3043 unsigned int nparam
, sparam
;
3044 int brackets
, rescan
;
3045 Token
*org_tline
= tline
;
3048 int deadman
= DEADMAN_LIMIT
;
3051 * Trick: we should avoid changing the start token pointer since it can
3052 * be contained in "next" field of other token. Because of this
3053 * we allocate a copy of first token and work with it; at the end of
3054 * routine we copy it back
3058 new_Token(org_tline
->next
, org_tline
->type
, org_tline
->text
,
3060 tline
->mac
= org_tline
->mac
;
3061 nasm_free(org_tline
->text
);
3062 org_tline
->text
= NULL
;
3069 while (tline
) { /* main token loop */
3071 error(ERR_NONFATAL
, "interminable macro recursion");
3075 if ((mname
= tline
->text
)) {
3076 /* if this token is a local macro, look in local context */
3079 if (tline
->type
== TOK_ID
|| tline
->type
== TOK_PREPROC_ID
) {
3080 ctx
= get_ctx(mname
, true);
3082 smtbl
= &ctx
->localmac
;
3084 head
= (SMacro
*) hash_findix(smtbl
, mname
);
3087 * We've hit an identifier. As in is_mmacro below, we first
3088 * check whether the identifier is a single-line macro at
3089 * all, then think about checking for parameters if
3092 for (m
= head
; m
; m
= m
->next
)
3093 if (!mstrcmp(m
->name
, mname
, m
->casesense
))
3099 if (m
->nparam
== 0) {
3101 * Simple case: the macro is parameterless. Discard the
3102 * one token that the macro call took, and push the
3103 * expansion back on the to-do stack.
3105 if (!m
->expansion
) {
3106 if (!strcmp("__FILE__", m
->name
)) {
3108 src_get(&num
, &(tline
->text
));
3109 nasm_quote(&(tline
->text
));
3110 tline
->type
= TOK_STRING
;
3113 if (!strcmp("__LINE__", m
->name
)) {
3114 nasm_free(tline
->text
);
3115 make_tok_num(tline
, src_get_linnum());
3118 if (!strcmp("__BITS__", m
->name
)) {
3119 nasm_free(tline
->text
);
3120 make_tok_num(tline
, globalbits
);
3123 tline
= delete_Token(tline
);
3128 * Complicated case: at least one macro with this name
3129 * exists and takes parameters. We must find the
3130 * parameters in the call, count them, find the SMacro
3131 * that corresponds to that form of the macro call, and
3132 * substitute for the parameters when we expand. What a
3135 /*tline = tline->next;
3136 skip_white_(tline); */
3139 while (tok_type_(t
, TOK_SMAC_END
)) {
3140 t
->mac
->in_progress
= false;
3142 t
= tline
->next
= delete_Token(t
);
3145 } while (tok_type_(tline
, TOK_WHITESPACE
));
3146 if (!tok_is_(tline
, "(")) {
3148 * This macro wasn't called with parameters: ignore
3149 * the call. (Behaviour borrowed from gnu cpp.)
3158 sparam
= PARAM_DELTA
;
3159 params
= nasm_malloc(sparam
* sizeof(Token
*));
3160 params
[0] = tline
->next
;
3161 paramsize
= nasm_malloc(sparam
* sizeof(int));
3163 while (true) { /* parameter loop */
3165 * For some unusual expansions
3166 * which concatenates function call
3169 while (tok_type_(t
, TOK_SMAC_END
)) {
3170 t
->mac
->in_progress
= false;
3172 t
= tline
->next
= delete_Token(t
);
3178 "macro call expects terminating `)'");
3181 if (tline
->type
== TOK_WHITESPACE
3183 if (paramsize
[nparam
])
3186 params
[nparam
] = tline
->next
;
3187 continue; /* parameter loop */
3189 if (tline
->type
== TOK_OTHER
3190 && tline
->text
[1] == 0) {
3191 char ch
= tline
->text
[0];
3192 if (ch
== ',' && !paren
&& brackets
<= 0) {
3193 if (++nparam
>= sparam
) {
3194 sparam
+= PARAM_DELTA
;
3195 params
= nasm_realloc(params
,
3200 nasm_realloc(paramsize
,
3204 params
[nparam
] = tline
->next
;
3205 paramsize
[nparam
] = 0;
3207 continue; /* parameter loop */
3210 (brackets
> 0 || (brackets
== 0 &&
3211 !paramsize
[nparam
])))
3213 if (!(brackets
++)) {
3214 params
[nparam
] = tline
->next
;
3215 continue; /* parameter loop */
3218 if (ch
== '}' && brackets
> 0)
3219 if (--brackets
== 0) {
3221 continue; /* parameter loop */
3223 if (ch
== '(' && !brackets
)
3225 if (ch
== ')' && brackets
<= 0)
3231 error(ERR_NONFATAL
, "braces do not "
3232 "enclose all of macro parameter");
3234 paramsize
[nparam
] += white
+ 1;
3236 } /* parameter loop */
3238 while (m
&& (m
->nparam
!= nparam
||
3239 mstrcmp(m
->name
, mname
,
3243 error(ERR_WARNING
| ERR_WARN_MNP
,
3244 "macro `%s' exists, "
3245 "but not taking %d parameters",
3246 mstart
->text
, nparam
);
3249 if (m
&& m
->in_progress
)
3251 if (!m
) { /* in progess or didn't find '(' or wrong nparam */
3253 * Design question: should we handle !tline, which
3254 * indicates missing ')' here, or expand those
3255 * macros anyway, which requires the (t) test a few
3259 nasm_free(paramsize
);
3263 * Expand the macro: we are placed on the last token of the
3264 * call, so that we can easily split the call from the
3265 * following tokens. We also start by pushing an SMAC_END
3266 * token for the cycle removal.
3273 tt
= new_Token(tline
, TOK_SMAC_END
, NULL
, 0);
3275 m
->in_progress
= true;
3277 for (t
= m
->expansion
; t
; t
= t
->next
) {
3278 if (t
->type
>= TOK_SMAC_PARAM
) {
3279 Token
*pcopy
= tline
, **ptail
= &pcopy
;
3283 ttt
= params
[t
->type
- TOK_SMAC_PARAM
];
3284 for (i
= paramsize
[t
->type
- TOK_SMAC_PARAM
];
3287 new_Token(tline
, ttt
->type
, ttt
->text
,
3293 } else if (t
->type
== TOK_PREPROC_Q
) {
3294 tt
= new_Token(tline
, TOK_ID
, mname
, 0);
3296 } else if (t
->type
== TOK_PREPROC_QQ
) {
3297 tt
= new_Token(tline
, TOK_ID
, m
->name
, 0);
3300 tt
= new_Token(tline
, t
->type
, t
->text
, 0);
3306 * Having done that, get rid of the macro call, and clean
3307 * up the parameters.
3310 nasm_free(paramsize
);
3312 continue; /* main token loop */
3317 if (tline
->type
== TOK_SMAC_END
) {
3318 tline
->mac
->in_progress
= false;
3319 tline
= delete_Token(tline
);
3322 tline
= tline
->next
;
3330 * Now scan the entire line and look for successive TOK_IDs that resulted
3331 * after expansion (they can't be produced by tokenize()). The successive
3332 * TOK_IDs should be concatenated.
3333 * Also we look for %+ tokens and concatenate the tokens before and after
3334 * them (without white spaces in between).
3339 while (t
&& t
->type
!= TOK_ID
&& t
->type
!= TOK_PREPROC_ID
)
3343 if (t
->next
->type
== TOK_ID
||
3344 t
->next
->type
== TOK_PREPROC_ID
||
3345 t
->next
->type
== TOK_NUMBER
) {
3346 char *p
= nasm_strcat(t
->text
, t
->next
->text
);
3348 t
->next
= delete_Token(t
->next
);
3351 } else if (t
->next
->type
== TOK_WHITESPACE
&& t
->next
->next
&&
3352 t
->next
->next
->type
== TOK_PREPROC_ID
&&
3353 strcmp(t
->next
->next
->text
, "%+") == 0) {
3354 /* free the next whitespace, the %+ token and next whitespace */
3356 for (i
= 1; i
<= 3; i
++) {
3358 || (i
!= 2 && t
->next
->type
!= TOK_WHITESPACE
))
3360 t
->next
= delete_Token(t
->next
);
3365 /* If we concatenaded something, re-scan the line for macros */
3373 *org_tline
= *thead
;
3374 /* since we just gave text to org_line, don't free it */
3376 delete_Token(thead
);
3378 /* the expression expanded to empty line;
3379 we can't return NULL for some reasons
3380 we just set the line to a single WHITESPACE token. */
3381 memset(org_tline
, 0, sizeof(*org_tline
));
3382 org_tline
->text
= NULL
;
3383 org_tline
->type
= TOK_WHITESPACE
;
3392 * Similar to expand_smacro but used exclusively with macro identifiers
3393 * right before they are fetched in. The reason is that there can be
3394 * identifiers consisting of several subparts. We consider that if there
3395 * are more than one element forming the name, user wants a expansion,
3396 * otherwise it will be left as-is. Example:
3400 * the identifier %$abc will be left as-is so that the handler for %define
3401 * will suck it and define the corresponding value. Other case:
3403 * %define _%$abc cde
3405 * In this case user wants name to be expanded *before* %define starts
3406 * working, so we'll expand %$abc into something (if it has a value;
3407 * otherwise it will be left as-is) then concatenate all successive
3410 static Token
*expand_id(Token
* tline
)
3412 Token
*cur
, *oldnext
= NULL
;
3414 if (!tline
|| !tline
->next
)
3419 (cur
->next
->type
== TOK_ID
||
3420 cur
->next
->type
== TOK_PREPROC_ID
3421 || cur
->next
->type
== TOK_NUMBER
))
3424 /* If identifier consists of just one token, don't expand */
3429 oldnext
= cur
->next
; /* Detach the tail past identifier */
3430 cur
->next
= NULL
; /* so that expand_smacro stops here */
3433 tline
= expand_smacro(tline
);
3436 /* expand_smacro possibly changhed tline; re-scan for EOL */
3438 while (cur
&& cur
->next
)
3441 cur
->next
= oldnext
;
3448 * Determine whether the given line constitutes a multi-line macro
3449 * call, and return the MMacro structure called if so. Doesn't have
3450 * to check for an initial label - that's taken care of in
3451 * expand_mmacro - but must check numbers of parameters. Guaranteed
3452 * to be called with tline->type == TOK_ID, so the putative macro
3453 * name is easy to find.
3455 static MMacro
*is_mmacro(Token
* tline
, Token
*** params_array
)
3461 head
= (MMacro
*) hash_findix(&mmacros
, tline
->text
);
3464 * Efficiency: first we see if any macro exists with the given
3465 * name. If not, we can return NULL immediately. _Then_ we
3466 * count the parameters, and then we look further along the
3467 * list if necessary to find the proper MMacro.
3469 for (m
= head
; m
; m
= m
->next
)
3470 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
3476 * OK, we have a potential macro. Count and demarcate the
3479 count_mmac_params(tline
->next
, &nparam
, ¶ms
);
3482 * So we know how many parameters we've got. Find the MMacro
3483 * structure that handles this number.
3486 if (m
->nparam_min
<= nparam
3487 && (m
->plus
|| nparam
<= m
->nparam_max
)) {
3489 * This one is right. Just check if cycle removal
3490 * prohibits us using it before we actually celebrate...
3492 if (m
->in_progress
) {
3495 "self-reference in multi-line macro `%s'", m
->name
);
3501 * It's right, and we can use it. Add its default
3502 * parameters to the end of our list if necessary.
3504 if (m
->defaults
&& nparam
< m
->nparam_min
+ m
->ndefs
) {
3506 nasm_realloc(params
,
3507 ((m
->nparam_min
+ m
->ndefs
+
3508 1) * sizeof(*params
)));
3509 while (nparam
< m
->nparam_min
+ m
->ndefs
) {
3510 params
[nparam
] = m
->defaults
[nparam
- m
->nparam_min
];
3515 * If we've gone over the maximum parameter count (and
3516 * we're in Plus mode), ignore parameters beyond
3519 if (m
->plus
&& nparam
> m
->nparam_max
)
3520 nparam
= m
->nparam_max
;
3522 * Then terminate the parameter list, and leave.
3524 if (!params
) { /* need this special case */
3525 params
= nasm_malloc(sizeof(*params
));
3528 params
[nparam
] = NULL
;
3529 *params_array
= params
;
3533 * This one wasn't right: look for the next one with the
3536 for (m
= m
->next
; m
; m
= m
->next
)
3537 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
3542 * After all that, we didn't find one with the right number of
3543 * parameters. Issue a warning, and fail to expand the macro.
3545 error(ERR_WARNING
| ERR_WARN_MNP
,
3546 "macro `%s' exists, but not taking %d parameters",
3547 tline
->text
, nparam
);
3553 * Expand the multi-line macro call made by the given line, if
3554 * there is one to be expanded. If there is, push the expansion on
3555 * istk->expansion and return 1. Otherwise return 0.
3557 static int expand_mmacro(Token
* tline
)
3559 Token
*startline
= tline
;
3560 Token
*label
= NULL
;
3561 int dont_prepend
= 0;
3562 Token
**params
, *t
, *mtok
, *tt
;
3565 int i
, nparam
, *paramlen
;
3569 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
3570 if (!tok_type_(t
, TOK_ID
) && !tok_type_(t
, TOK_PREPROC_ID
))
3573 m
= is_mmacro(t
, ¶ms
);
3577 * We have an id which isn't a macro call. We'll assume
3578 * it might be a label; we'll also check to see if a
3579 * colon follows it. Then, if there's another id after
3580 * that lot, we'll check it again for macro-hood.
3584 if (tok_type_(t
, TOK_WHITESPACE
))
3585 last
= t
, t
= t
->next
;
3586 if (tok_is_(t
, ":")) {
3588 last
= t
, t
= t
->next
;
3589 if (tok_type_(t
, TOK_WHITESPACE
))
3590 last
= t
, t
= t
->next
;
3592 if (!tok_type_(t
, TOK_ID
) || (m
= is_mmacro(t
, ¶ms
)) == NULL
)
3599 * Fix up the parameters: this involves stripping leading and
3600 * trailing whitespace, then stripping braces if they are
3603 for (nparam
= 0; params
[nparam
]; nparam
++) ;
3604 paramlen
= nparam
? nasm_malloc(nparam
* sizeof(*paramlen
)) : NULL
;
3606 for (i
= 0; params
[i
]; i
++) {
3608 int comma
= (!m
->plus
|| i
< nparam
- 1);
3612 if (tok_is_(t
, "{"))
3613 t
= t
->next
, brace
= true, comma
= false;
3617 if (comma
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, ","))
3618 break; /* ... because we have hit a comma */
3619 if (comma
&& t
->type
== TOK_WHITESPACE
3620 && tok_is_(t
->next
, ","))
3621 break; /* ... or a space then a comma */
3622 if (brace
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, "}"))
3623 break; /* ... or a brace */
3630 * OK, we have a MMacro structure together with a set of
3631 * parameters. We must now go through the expansion and push
3632 * copies of each Line on to istk->expansion. Substitution of
3633 * parameter tokens and macro-local tokens doesn't get done
3634 * until the single-line macro substitution process; this is
3635 * because delaying them allows us to change the semantics
3636 * later through %rotate.
3638 * First, push an end marker on to istk->expansion, mark this
3639 * macro as in progress, and set up its invocation-specific
3642 ll
= nasm_malloc(sizeof(Line
));
3643 ll
->next
= istk
->expansion
;
3646 istk
->expansion
= ll
;
3648 m
->in_progress
= true;
3653 m
->paramlen
= paramlen
;
3654 m
->unique
= unique
++;
3657 m
->next_active
= istk
->mstk
;
3660 for (l
= m
->expansion
; l
; l
= l
->next
) {
3663 ll
= nasm_malloc(sizeof(Line
));
3664 ll
->finishes
= NULL
;
3665 ll
->next
= istk
->expansion
;
3666 istk
->expansion
= ll
;
3669 for (t
= l
->first
; t
; t
= t
->next
) {
3673 tt
= *tail
= new_Token(NULL
, TOK_ID
, mtok
->text
, 0);
3675 case TOK_PREPROC_QQ
:
3676 tt
= *tail
= new_Token(NULL
, TOK_ID
, m
->name
, 0);
3678 case TOK_PREPROC_ID
:
3679 if (t
->text
[1] == '0' && t
->text
[2] == '0') {
3687 tt
= *tail
= new_Token(NULL
, x
->type
, x
->text
, 0);
3696 * If we had a label, push it on as the first line of
3697 * the macro expansion.
3700 if (dont_prepend
< 0)
3701 free_tlist(startline
);
3703 ll
= nasm_malloc(sizeof(Line
));
3704 ll
->finishes
= NULL
;
3705 ll
->next
= istk
->expansion
;
3706 istk
->expansion
= ll
;
3707 ll
->first
= startline
;
3708 if (!dont_prepend
) {
3710 label
= label
->next
;
3711 label
->next
= tt
= new_Token(NULL
, TOK_OTHER
, ":", 0);
3716 list
->uplevel(m
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
3722 * Since preprocessor always operate only on the line that didn't
3723 * arrived yet, we should always use ERR_OFFBY1. Also since user
3724 * won't want to see same error twice (preprocessing is done once
3725 * per pass) we will want to show errors only during pass one.
3727 static void error(int severity
, const char *fmt
, ...)
3732 /* If we're in a dead branch of IF or something like it, ignore the error */
3733 if (istk
&& istk
->conds
&& !emitting(istk
->conds
->state
))
3737 vsnprintf(buff
, sizeof(buff
), fmt
, arg
);
3740 if (istk
&& istk
->mstk
&& istk
->mstk
->name
)
3741 _error(severity
| ERR_PASS1
, "(%s:%d) %s", istk
->mstk
->name
,
3742 istk
->mstk
->lineno
, buff
);
3744 _error(severity
| ERR_PASS1
, "%s", buff
);
3748 pp_reset(char *file
, int apass
, efunc errfunc
, evalfunc eval
,
3749 ListGen
* listgen
, StrList
**deplist
)
3753 istk
= nasm_malloc(sizeof(Include
));
3756 istk
->expansion
= NULL
;
3758 istk
->fp
= fopen(file
, "r");
3760 src_set_fname(nasm_strdup(file
));
3764 error(ERR_FATAL
| ERR_NOFILE
, "unable to open input file `%s'",
3769 if (tasm_compatible_mode
) {
3770 stdmacpos
= nasm_stdmac
;
3772 stdmacpos
= nasm_stdmac_after_tasm
;
3774 any_extrastdmac
= (extrastdmac
!= NULL
);
3778 dephead
= deptail
= deplist
;
3780 StrList
*sl
= nasm_malloc(strlen(file
)+1+sizeof sl
->next
);
3782 strcpy(sl
->str
, file
);
3784 deptail
= &sl
->next
;
3788 static char *pp_getline(void)
3795 * Fetch a tokenized line, either from the macro-expansion
3796 * buffer or from the input file.
3799 while (istk
->expansion
&& istk
->expansion
->finishes
) {
3800 Line
*l
= istk
->expansion
;
3801 if (!l
->finishes
->name
&& l
->finishes
->in_progress
> 1) {
3805 * This is a macro-end marker for a macro with no
3806 * name, which means it's not really a macro at all
3807 * but a %rep block, and the `in_progress' field is
3808 * more than 1, meaning that we still need to
3809 * repeat. (1 means the natural last repetition; 0
3810 * means termination by %exitrep.) We have
3811 * therefore expanded up to the %endrep, and must
3812 * push the whole block on to the expansion buffer
3813 * again. We don't bother to remove the macro-end
3814 * marker: we'd only have to generate another one
3817 l
->finishes
->in_progress
--;
3818 for (l
= l
->finishes
->expansion
; l
; l
= l
->next
) {
3819 Token
*t
, *tt
, **tail
;
3821 ll
= nasm_malloc(sizeof(Line
));
3822 ll
->next
= istk
->expansion
;
3823 ll
->finishes
= NULL
;
3827 for (t
= l
->first
; t
; t
= t
->next
) {
3828 if (t
->text
|| t
->type
== TOK_WHITESPACE
) {
3830 new_Token(NULL
, t
->type
, t
->text
, 0);
3835 istk
->expansion
= ll
;
3839 * Check whether a `%rep' was started and not ended
3840 * within this macro expansion. This can happen and
3841 * should be detected. It's a fatal error because
3842 * I'm too confused to work out how to recover
3848 "defining with name in expansion");
3849 else if (istk
->mstk
->name
)
3851 "`%%rep' without `%%endrep' within"
3852 " expansion of macro `%s'",
3857 * FIXME: investigate the relationship at this point between
3858 * istk->mstk and l->finishes
3861 MMacro
*m
= istk
->mstk
;
3862 istk
->mstk
= m
->next_active
;
3865 * This was a real macro call, not a %rep, and
3866 * therefore the parameter information needs to
3869 nasm_free(m
->params
);
3870 free_tlist(m
->iline
);
3871 nasm_free(m
->paramlen
);
3872 l
->finishes
->in_progress
= false;
3876 istk
->expansion
= l
->next
;
3878 list
->downlevel(LIST_MACRO
);
3881 while (1) { /* until we get a line we can use */
3883 if (istk
->expansion
) { /* from a macro expansion */
3885 Line
*l
= istk
->expansion
;
3887 istk
->mstk
->lineno
++;
3889 istk
->expansion
= l
->next
;
3891 p
= detoken(tline
, false);
3892 list
->line(LIST_MACRO
, p
);
3897 if (line
) { /* from the current input file */
3898 line
= prepreproc(line
);
3899 tline
= tokenize(line
);
3904 * The current file has ended; work down the istk
3911 "expected `%%endif' before end of file");
3912 /* only set line and file name if there's a next node */
3914 src_set_linnum(i
->lineno
);
3915 nasm_free(src_set_fname(i
->fname
));
3918 list
->downlevel(LIST_INCLUDE
);
3926 * We must expand MMacro parameters and MMacro-local labels
3927 * _before_ we plunge into directive processing, to cope
3928 * with things like `%define something %1' such as STRUC
3929 * uses. Unless we're _defining_ a MMacro, in which case
3930 * those tokens should be left alone to go into the
3931 * definition; and unless we're in a non-emitting
3932 * condition, in which case we don't want to meddle with
3935 if (!defining
&& !(istk
->conds
&& !emitting(istk
->conds
->state
)))
3936 tline
= expand_mmac_params(tline
);
3939 * Check the line to see if it's a preprocessor directive.
3941 if (do_directive(tline
) == DIRECTIVE_FOUND
) {
3943 } else if (defining
) {
3945 * We're defining a multi-line macro. We emit nothing
3947 * shove the tokenized line on to the macro definition.
3949 Line
*l
= nasm_malloc(sizeof(Line
));
3950 l
->next
= defining
->expansion
;
3952 l
->finishes
= false;
3953 defining
->expansion
= l
;
3955 } else if (istk
->conds
&& !emitting(istk
->conds
->state
)) {
3957 * We're in a non-emitting branch of a condition block.
3958 * Emit nothing at all, not even a blank line: when we
3959 * emerge from the condition we'll give a line-number
3960 * directive so we keep our place correctly.
3964 } else if (istk
->mstk
&& !istk
->mstk
->in_progress
) {
3966 * We're in a %rep block which has been terminated, so
3967 * we're walking through to the %endrep without
3968 * emitting anything. Emit nothing at all, not even a
3969 * blank line: when we emerge from the %rep block we'll
3970 * give a line-number directive so we keep our place
3976 tline
= expand_smacro(tline
);
3977 if (!expand_mmacro(tline
)) {
3979 * De-tokenize the line again, and emit it.
3981 line
= detoken(tline
, true);
3985 continue; /* expand_mmacro calls free_tlist */
3993 static void pp_cleanup(int pass
)
3996 error(ERR_NONFATAL
, "end of file while still defining macro `%s'",
3998 free_mmacro(defining
);
4007 nasm_free(i
->fname
);
4018 void pp_include_path(char *path
)
4022 i
= nasm_malloc(sizeof(IncPath
));
4023 i
->path
= path
? nasm_strdup(path
) : NULL
;
4026 if (ipath
!= NULL
) {
4028 while (j
->next
!= NULL
)
4039 * This function is used to "export" the include paths, e.g.
4040 * the paths specified in the '-I' command switch.
4041 * The need for such exporting is due to the 'incbin' directive,
4042 * which includes raw binary files (unlike '%include', which
4043 * includes text source files). It would be real nice to be
4044 * able to specify paths to search for incbin'ned files also.
4045 * So, this is a simple workaround.
4047 * The function use is simple:
4049 * The 1st call (with NULL argument) returns a pointer to the 1st path
4050 * (char** type) or NULL if none include paths available.
4052 * All subsequent calls take as argument the value returned by this
4053 * function last. The return value is either the next path
4054 * (char** type) or NULL if the end of the paths list is reached.
4056 * It is maybe not the best way to do things, but I didn't want
4057 * to export too much, just one or two functions and no types or
4058 * variables exported.
4060 * Can't say I like the current situation with e.g. this path list either,
4061 * it seems to be never deallocated after creation...
4063 char **pp_get_include_path_ptr(char **pPrevPath
)
4065 /* This macro returns offset of a member of a structure */
4066 #define GetMemberOffset(StructType,MemberName)\
4067 ((size_t)&((StructType*)0)->MemberName)
4070 if (pPrevPath
== NULL
) {
4072 return &ipath
->path
;
4076 i
= (IncPath
*) ((char *)pPrevPath
- GetMemberOffset(IncPath
, path
));
4082 #undef GetMemberOffset
4085 void pp_pre_include(char *fname
)
4087 Token
*inc
, *space
, *name
;
4090 name
= new_Token(NULL
, TOK_INTERNAL_STRING
, fname
, 0);
4091 space
= new_Token(name
, TOK_WHITESPACE
, NULL
, 0);
4092 inc
= new_Token(space
, TOK_PREPROC_ID
, "%include", 0);
4094 l
= nasm_malloc(sizeof(Line
));
4097 l
->finishes
= false;
4101 void pp_pre_define(char *definition
)
4107 equals
= strchr(definition
, '=');
4108 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4109 def
= new_Token(space
, TOK_PREPROC_ID
, "%define", 0);
4112 space
->next
= tokenize(definition
);
4116 l
= nasm_malloc(sizeof(Line
));
4119 l
->finishes
= false;
4123 void pp_pre_undefine(char *definition
)
4128 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4129 def
= new_Token(space
, TOK_PREPROC_ID
, "%undef", 0);
4130 space
->next
= tokenize(definition
);
4132 l
= nasm_malloc(sizeof(Line
));
4135 l
->finishes
= false;
4140 * Added by Keith Kanios:
4142 * This function is used to assist with "runtime" preprocessor
4143 * directives. (e.g. pp_runtime("%define __BITS__ 64");)
4145 * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
4146 * PASS A VALID STRING TO THIS FUNCTION!!!!!
4149 void pp_runtime(char *definition
)
4153 def
= tokenize(definition
);
4154 if(do_directive(def
) == NO_DIRECTIVE_FOUND
)
4159 void pp_extra_stdmac(const char **macros
)
4161 extrastdmac
= macros
;
4164 static void make_tok_num(Token
* tok
, int64_t val
)
4167 snprintf(numbuf
, sizeof(numbuf
), "%"PRId64
"", val
);
4168 tok
->text
= nasm_strdup(numbuf
);
4169 tok
->type
= TOK_NUMBER
;