1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2010 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above
14 * copyright notice, this list of conditions and the following
15 * disclaimer in the documentation and/or other materials provided
16 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 * ----------------------------------------------------------------------- */
35 * preproc.c macro preprocessor for the Netwide Assembler
38 /* Typical flow of text through preproc
40 * pp_getline gets tokenized lines, either
42 * from a macro expansion
46 * read_line gets raw text from stdmacpos, or predef, or current input file
47 * tokenize converts to tokens
50 * expand_mmac_params is used to expand %1 etc., unless a macro is being
51 * defined or a false conditional is being processed
52 * (%0, %1, %+1, %-1, %%foo
54 * do_directive checks for directives
56 * expand_smacro is used to expand single line macros
58 * expand_mmacro is used to expand multi-line macros
60 * detoken is used to convert the line back to text
84 typedef struct SMacro SMacro
;
85 typedef struct ExpDef ExpDef
;
86 typedef struct ExpInv ExpInv
;
87 typedef struct Context Context
;
88 typedef struct Token Token
;
89 typedef struct Blocks Blocks
;
90 typedef struct Line Line
;
91 typedef struct Include Include
;
92 typedef struct Cond Cond
;
93 typedef struct IncPath IncPath
;
96 * Note on the storage of both SMacro and MMacros: the hash table
97 * indexes them case-insensitively, and we then have to go through a
98 * linked list of potential case aliases (and, for MMacros, parameter
99 * ranges); this is to preserve the matching semantics of the earlier
100 * code. If the number of case aliases for a specific macro is a
101 * performance issue, you may want to reconsider your coding style.
105 * Store the definition of a single-line macro.
117 * The context stack is composed of a linked list of these.
122 struct hash_table localmac
;
127 * This is the internal form which we break input lines up into.
128 * Typically stored in linked lists.
130 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
131 * necessarily used as-is, but is intended to denote the number of
132 * the substituted parameter. So in the definition
134 * %define a(x,y) ( (x) & ~(y) )
136 * the token representing `x' will have its type changed to
137 * TOK_SMAC_PARAM, but the one representing `y' will be
140 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
141 * which doesn't need quotes around it. Used in the pre-include
142 * mechanism as an alternative to trying to find a sensible type of
143 * quote to use on the filename we were passed.
146 TOK_NONE
= 0, TOK_WHITESPACE
, TOK_COMMENT
, TOK_ID
,
147 TOK_PREPROC_ID
, TOK_STRING
,
148 TOK_NUMBER
, TOK_FLOAT
, TOK_SMAC_END
, TOK_OTHER
,
150 TOK_PREPROC_Q
, TOK_PREPROC_QQ
,
152 TOK_INDIRECT
, /* %[...] */
153 TOK_SMAC_PARAM
, /* MUST BE LAST IN THE LIST!!! */
154 TOK_MAX
= INT_MAX
/* Keep compiler from reducing the range */
157 #define PP_CONCAT_MASK(x) (1 << (x))
159 struct tokseq_match
{
168 SMacro
*mac
; /* associated macro for TOK_SMAC_END */
169 size_t len
; /* scratch length field */
170 } a
; /* Auxiliary data */
171 enum pp_token_type type
;
175 * Expansion definitions are stored as a linked list of
176 * these, which is essentially a container to allow several linked
179 * Note that in this module, linked lists are treated as stacks
180 * wherever possible. For this reason, Lines are _pushed_ on to the
181 * `last' field in ExpDef structures, so that the linked list,
182 * if walked, would emit the expansion lines in the proper order.
193 EXP_NONE
= 0, EXP_PREDEF
,
196 EXP_COMMENT
, EXP_FINAL
,
197 EXP_MAX
= INT_MAX
/* Keep compiler from reducing the range */
201 * Store the definition of an expansion, in which is any
202 * preprocessor directive that has an ending pair.
204 * This design allows for arbitrary expansion/recursion depth,
205 * upto the DEADMAN_LIMIT.
207 * The `next' field is used for storing ExpDef in hash tables; the
208 * `prev' field is for the global `expansions` linked-list.
211 ExpDef
*prev
; /* previous definition */
212 ExpDef
*next
; /* next in hash table */
213 enum pp_exp_type type
; /* expansion type */
214 char *name
; /* definition name */
215 int nparam_min
, nparam_max
;
217 bool plus
; /* is the last parameter greedy? */
218 bool nolist
; /* is this expansion listing-inhibited? */
219 Token
*dlist
; /* all defaults as one list */
220 Token
**defaults
; /* parameter default pointers */
221 int ndefs
; /* number of default parameters */
223 int prepend
; /* label prepend state */
227 int linecount
; /* number of lines within expansion */
229 int64_t def_depth
; /* current number of definition pairs deep */
230 int64_t cur_depth
; /* current number of expansions */
231 int64_t max_depth
; /* maximum number of expansions allowed */
233 int state
; /* condition state */
234 bool ignoring
; /* ignoring definition lines */
238 * Store the invocation of an expansion.
240 * The `prev' field is for the `istk->expansion` linked-list.
242 * When an expansion is being expanded, `params', `iline', `nparam',
243 * `paramlen', `rotate' and `unique' are local to the invocation.
246 ExpInv
*prev
; /* previous invocation */
247 enum pp_exp_type type
; /* expansion type */
248 ExpDef
*def
; /* pointer to expansion definition */
249 char *name
; /* invocation name */
250 Line
*label
; /* pointer to label */
251 char *label_text
; /* pointer to label text */
252 Line
*current
; /* pointer to current line in invocation */
254 Token
**params
; /* actual parameters */
255 Token
*iline
; /* invocation line */
256 unsigned int nparam
, rotate
;
261 int lineno
; /* current line number in expansion */
262 int linnum
; /* line number at invocation */
263 int relno
; /* relative line number at invocation */
267 * To handle an arbitrary level of file inclusion, we maintain a
268 * stack (ie linked list) of these things.
281 * Include search path. This is simply a list of strings which get
282 * prepended, in turn, to the name of an include file, in an
283 * attempt to find the file if it's not in the current directory.
291 * Conditional assembly: we maintain a separate stack of these for
292 * each level of file inclusion. (The only reason we keep the
293 * stacks separate is to ensure that a stray `%endif' in a file
294 * included from within the true branch of a `%if' won't terminate
295 * it and cause confusion: instead, rightly, it'll cause an error.)
299 * These states are for use just after %if or %elif: IF_TRUE
300 * means the condition has evaluated to truth so we are
301 * currently emitting, whereas IF_FALSE means we are not
302 * currently emitting but will start doing so if a %else comes
303 * up. In these states, all directives are admissible: %elif,
304 * %else and %endif. (And of course %if.)
306 COND_IF_TRUE
, COND_IF_FALSE
,
308 * These states come up after a %else: ELSE_TRUE means we're
309 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
310 * any %elif or %else will cause an error.
312 COND_ELSE_TRUE
, COND_ELSE_FALSE
,
314 * These states mean that we're not emitting now, and also that
315 * nothing until %endif will be emitted at all. COND_DONE is
316 * used when we've had our moment of emission
317 * and have now started seeing %elifs. COND_NEVER is used when
318 * the condition construct in question is contained within a
319 * non-emitting branch of a larger condition construct,
320 * or if there is an error.
322 COND_DONE
, COND_NEVER
324 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
327 * These defines are used as the possible return values for do_directive
329 #define NO_DIRECTIVE_FOUND 0
330 #define DIRECTIVE_FOUND 1
333 * This define sets the upper limit for smacro and expansions
335 #define DEADMAN_LIMIT (1 << 20)
338 #define REP_LIMIT ((INT64_C(1) << 62))
341 * Condition codes. Note that we use c_ prefix not C_ because C_ is
342 * used in nasm.h for the "real" condition codes. At _this_ level,
343 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
344 * ones, so we need a different enum...
346 static const char * const conditions
[] = {
347 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
348 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
349 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
352 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_CXZ
, c_E
, c_ECXZ
, c_G
, c_GE
, c_L
, c_LE
,
353 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, c_NE
, c_NG
, c_NGE
, c_NL
, c_NLE
, c_NO
,
354 c_NP
, c_NS
, c_NZ
, c_O
, c_P
, c_PE
, c_PO
, c_RCXZ
, c_S
, c_Z
,
357 static const enum pp_conds inverse_ccs
[] = {
358 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, -1, c_NE
, -1, c_NG
, c_NGE
, c_NL
, c_NLE
,
359 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_E
, c_G
, c_GE
, c_L
, c_LE
, c_O
, c_P
, c_S
,
360 c_Z
, c_NO
, c_NP
, c_PO
, c_PE
, -1, c_NS
, c_NZ
363 /* For TASM compatibility we need to be able to recognise TASM compatible
364 * conditional compilation directives. Using the NASM pre-processor does
365 * not work, so we look for them specifically from the following list and
366 * then jam in the equivalent NASM directive into the input stream.
370 TM_ARG
, TM_ELIF
, TM_ELSE
, TM_ENDIF
, TM_IF
, TM_IFDEF
, TM_IFDIFI
,
371 TM_IFNDEF
, TM_INCLUDE
, TM_LOCAL
374 static const char * const tasm_directives
[] = {
375 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
376 "ifndef", "include", "local"
379 static int StackSize
= 4;
380 static char *StackPointer
= "ebp";
381 static int ArgOffset
= 8;
382 static int LocalOffset
= 0;
384 static Context
*cstk
;
385 static Include
*istk
;
386 static IncPath
*ipath
= NULL
;
388 static int pass
; /* HACK: pass 0 = generate dependencies only */
389 static StrList
**dephead
, **deptail
; /* Dependency list */
391 static uint64_t unique
; /* unique identifier numbers */
393 static Line
*predef
= NULL
;
394 static bool do_predef
;
396 static ListGen
*list
;
399 * The current set of expansion definitions we have defined.
401 static struct hash_table expdefs
;
404 * The current set of single-line macros we have defined.
406 static struct hash_table smacros
;
409 * Linked List of all active expansion definitions
411 struct ExpDef
*expansions
= NULL
;
414 * The expansion we are currently defining
416 static ExpDef
*defining
= NULL
;
418 static uint64_t nested_mac_count
;
419 static uint64_t nested_rep_count
;
422 * Linked-list of lines to preprocess, prior to cleanup
424 static Line
*finals
= NULL
;
425 static bool in_final
= false;
428 * The number of macro parameters to allocate space for at a time.
430 #define PARAM_DELTA 16
433 * The standard macro set: defined in macros.c in the array nasm_stdmac.
434 * This gives our position in the macro set, when we're processing it.
436 static macros_t
*stdmacpos
;
439 * The extra standard macros that come from the object format, if
442 static macros_t
*extrastdmac
= NULL
;
443 static bool any_extrastdmac
;
446 * Tokens are allocated in blocks to improve speed
448 #define TOKEN_BLOCKSIZE 4096
449 static Token
*freeTokens
= NULL
;
455 static Blocks blocks
= { NULL
, NULL
};
458 * Forward declarations.
460 static Token
*expand_mmac_params(Token
* tline
);
461 static Token
*expand_smacro(Token
* tline
);
462 static Token
*expand_id(Token
* tline
);
463 static Context
*get_ctx(const char *name
, const char **namep
,
465 static void make_tok_num(Token
* tok
, int64_t val
);
466 static void error(int severity
, const char *fmt
, ...);
467 static void error_precond(int severity
, const char *fmt
, ...);
468 static void *new_Block(size_t size
);
469 static void delete_Blocks(void);
470 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
471 const char *text
, int txtlen
);
472 static Token
*copy_Token(Token
* tline
);
473 static Token
*delete_Token(Token
* t
);
474 static Line
*new_Line(void);
475 static ExpDef
*new_ExpDef(int exp_type
);
476 static ExpInv
*new_ExpInv(int exp_type
, ExpDef
*ed
);
479 * Macros for safe checking of token pointers, avoid *(NULL)
481 #define tok_type_(x,t) ((x) && (x)->type == (t))
482 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
483 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
484 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
488 #define dump_token(t) raw_dump_token(t, __FILE__, __LINE__, __func__);
489 static void raw_dump_token(Token
*token
, const char *file
, int line
, const char *func
)
491 printf("---[%s (%s:%d): %p]---\n", func
, file
, line
, (void *)token
);
494 list_for_each(t
, token
) {
496 printf("'%s' ", t
->text
);
505 * nasm_unquote with error if the string contains NUL characters.
506 * If the string contains NUL characters, issue an error and return
507 * the C len, i.e. truncate at the NUL.
509 static size_t nasm_unquote_cstr(char *qstr
, enum preproc_token directive
)
511 size_t len
= nasm_unquote(qstr
, NULL
);
512 size_t clen
= strlen(qstr
);
515 error(ERR_NONFATAL
, "NUL character in `%s' directive",
516 pp_directives
[directive
]);
522 * In-place reverse a list of tokens.
524 static Token
*reverse_tokens(Token
*t
)
540 * Handle TASM specific directives, which do not contain a % in
541 * front of them. We do it here because I could not find any other
542 * place to do it for the moment, and it is a hack (ideally it would
543 * be nice to be able to use the NASM pre-processor to do it).
545 static char *check_tasm_directive(char *line
)
547 int32_t i
, j
, k
, m
, len
;
548 char *p
, *q
, *oldline
, oldchar
;
550 p
= nasm_skip_spaces(line
);
552 /* Binary search for the directive name */
554 j
= ARRAY_SIZE(tasm_directives
);
555 q
= nasm_skip_word(p
);
562 m
= nasm_stricmp(p
, tasm_directives
[k
]);
564 /* We have found a directive, so jam a % in front of it
565 * so that NASM will then recognise it as one if it's own.
570 line
= nasm_malloc(len
+ 2);
572 if (k
== TM_IFDIFI
) {
574 * NASM does not recognise IFDIFI, so we convert
575 * it to %if 0. This is not used in NASM
576 * compatible code, but does need to parse for the
577 * TASM macro package.
579 strcpy(line
+ 1, "if 0");
581 memcpy(line
+ 1, p
, len
+ 1);
596 * The pre-preprocessing stage... This function translates line
597 * number indications as they emerge from GNU cpp (`# lineno "file"
598 * flags') into NASM preprocessor line number indications (`%line
601 static char *prepreproc(char *line
)
604 char *fname
, *oldline
;
606 if (line
[0] == '#' && line
[1] == ' ') {
609 lineno
= atoi(fname
);
610 fname
+= strspn(fname
, "0123456789 ");
613 fnlen
= strcspn(fname
, "\"");
614 line
= nasm_malloc(20 + fnlen
);
615 snprintf(line
, 20 + fnlen
, "%%line %d %.*s", lineno
, fnlen
, fname
);
618 if (tasm_compatible_mode
)
619 return check_tasm_directive(line
);
624 * Free a linked list of tokens.
626 static void free_tlist(Token
* list
)
629 list
= delete_Token(list
);
633 * Free a linked list of lines.
635 static void free_llist(Line
* list
)
638 list_for_each_safe(l
, tmp
, list
) {
639 free_tlist(l
->first
);
647 static void free_expdef(ExpDef
* ed
)
650 free_tlist(ed
->dlist
);
651 nasm_free(ed
->defaults
);
652 free_llist(ed
->line
);
659 static void free_expinv(ExpInv
* ei
)
661 if (ei
->name
!= NULL
)
663 if (ei
->label_text
!= NULL
)
664 nasm_free(ei
->label_text
);
669 * Free all currently defined macros, and free the hash tables
671 static void free_smacro_table(struct hash_table
*smt
)
675 struct hash_tbl_node
*it
= NULL
;
677 while ((s
= hash_iterate(smt
, &it
, &key
)) != NULL
) {
678 nasm_free((void *)key
);
679 list_for_each_safe(s
, tmp
, s
) {
681 free_tlist(s
->expansion
);
688 static void free_expdef_table(struct hash_table
*edt
)
692 struct hash_tbl_node
*it
= NULL
;
695 while ((ed
= hash_iterate(edt
, &it
, &key
)) != NULL
) {
696 nasm_free((void *)key
);
697 list_for_each_safe(ed
,tmp
, ed
)
703 static void free_macros(void)
705 free_smacro_table(&smacros
);
706 free_expdef_table(&expdefs
);
710 * Initialize the hash tables
712 static void init_macros(void)
714 hash_init(&smacros
, HASH_LARGE
);
715 hash_init(&expdefs
, HASH_LARGE
);
719 * Pop the context stack.
721 static void ctx_pop(void)
726 free_smacro_table(&c
->localmac
);
732 * Search for a key in the hash index; adding it if necessary
733 * (in which case we initialize the data pointer to NULL.)
736 hash_findi_add(struct hash_table
*hash
, const char *str
)
738 struct hash_insert hi
;
742 r
= hash_findi(hash
, str
, &hi
);
746 strx
= nasm_strdup(str
); /* Use a more efficient allocator here? */
747 return hash_add(&hi
, strx
, NULL
);
751 * Like hash_findi, but returns the data element rather than a pointer
752 * to it. Used only when not adding a new element, hence no third
756 hash_findix(struct hash_table
*hash
, const char *str
)
760 p
= hash_findi(hash
, str
, NULL
);
761 return p
? *p
: NULL
;
765 * read line from standard macros set,
766 * if there no more left -- return NULL
768 static char *line_from_stdmac(void)
771 const unsigned char *p
= stdmacpos
;
780 len
+= pp_directives_len
[c
- 0x80] + 1;
785 line
= nasm_malloc(len
+ 1);
787 while ((c
= *stdmacpos
++)) {
789 memcpy(q
, pp_directives
[c
- 0x80], pp_directives_len
[c
- 0x80]);
790 q
+= pp_directives_len
[c
- 0x80];
800 /* This was the last of the standard macro chain... */
802 if (any_extrastdmac
) {
803 stdmacpos
= extrastdmac
;
804 any_extrastdmac
= false;
805 } else if (do_predef
) {
808 Token
*head
, **tail
, *t
;
811 * Nasty hack: here we push the contents of
812 * `predef' on to the top-level expansion stack,
813 * since this is the most convenient way to
814 * implement the pre-include and pre-define
817 list_for_each(pd
, predef
) {
820 list_for_each(t
, pd
->first
) {
821 *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
822 tail
= &(*tail
)->next
;
827 ei
= new_ExpInv(EXP_PREDEF
, NULL
);
830 ei
->prev
= istk
->expansion
;
831 istk
->expansion
= ei
;
840 #define BUF_DELTA 512
842 * Read a line from the top file in istk, handling multiple CR/LFs
843 * at the end of the line read, and handling spurious ^Zs. Will
844 * return lines from the standard macro set if this has not already
847 static char *read_line(void)
849 char *buffer
, *p
, *q
;
850 int bufsize
, continued_count
;
853 * standart macros set (predefined) goes first
855 p
= line_from_stdmac();
860 * regular read from a file
863 buffer
= nasm_malloc(BUF_DELTA
);
867 q
= fgets(p
, bufsize
- (p
- buffer
), istk
->fp
);
871 if (p
> buffer
&& p
[-1] == '\n') {
873 * Convert backslash-CRLF line continuation sequences into
874 * nothing at all (for DOS and Windows)
876 if (((p
- 2) > buffer
) && (p
[-3] == '\\') && (p
[-2] == '\r')) {
882 * Also convert backslash-LF line continuation sequences into
883 * nothing at all (for Unix)
885 else if (((p
- 1) > buffer
) && (p
[-2] == '\\')) {
893 if (p
- buffer
> bufsize
- 10) {
894 int32_t offset
= p
- buffer
;
895 bufsize
+= BUF_DELTA
;
896 buffer
= nasm_realloc(buffer
, bufsize
);
897 p
= buffer
+ offset
; /* prevent stale-pointer problems */
901 if (!q
&& p
== buffer
) {
906 src_set_linnum(src_get_linnum() + istk
->lineinc
+
907 (continued_count
* istk
->lineinc
));
910 * Play safe: remove CRs as well as LFs, if any of either are
911 * present at the end of the line.
913 while (--p
>= buffer
&& (*p
== '\n' || *p
== '\r'))
917 * Handle spurious ^Z, which may be inserted into source files
918 * by some file transfer utilities.
920 buffer
[strcspn(buffer
, "\032")] = '\0';
922 list
->line(LIST_READ
, buffer
);
928 * Tokenize a line of text. This is a very simple process since we
929 * don't need to parse the value out of e.g. numeric tokens: we
930 * simply split one string into many.
932 static Token
*tokenize(char *line
)
935 enum pp_token_type type
;
937 Token
*t
, **tail
= &list
;
940 if ((defining
!= NULL
) && (defining
->ignoring
== true)) {
948 if (*p
== '+' && !nasm_isdigit(p
[1])) {
951 } else if (nasm_isdigit(*p
) ||
952 ((*p
== '-' || *p
== '+') && nasm_isdigit(p
[1]))) {
956 while (nasm_isdigit(*p
));
957 type
= TOK_PREPROC_ID
;
958 } else if (*p
== '{') {
960 while (*p
&& *p
!= '}') {
967 type
= TOK_PREPROC_ID
;
968 } else if (*p
== '[') {
970 line
+= 2; /* Skip the leading %[ */
972 while (lvl
&& (c
= *p
++)) {
984 p
= nasm_skip_string(p
- 1) + 1;
994 error(ERR_NONFATAL
, "unterminated %[ construct");
996 } else if (*p
== '?') {
997 type
= TOK_PREPROC_Q
; /* %? */
1000 type
= TOK_PREPROC_QQ
; /* %?? */
1003 } else if (*p
== '!') {
1004 type
= TOK_PREPROC_ID
;
1009 } while (isidchar(*p
));
1010 } else if (*p
== '\'' || *p
== '\"' || *p
== '`') {
1011 p
= nasm_skip_string(p
);
1015 error(ERR_NONFATAL
|ERR_PASS1
, "unterminated %! string");
1017 /* %! without string or identifier */
1018 type
= TOK_OTHER
; /* Legacy behavior... */
1020 } else if (isidchar(*p
) ||
1021 ((*p
== '!' || *p
== '%' || *p
== '$') &&
1026 while (isidchar(*p
));
1027 type
= TOK_PREPROC_ID
;
1033 } else if (isidstart(*p
) || (*p
== '$' && isidstart(p
[1]))) {
1036 while (*p
&& isidchar(*p
))
1038 } else if (*p
== '\'' || *p
== '"' || *p
== '`') {
1043 p
= nasm_skip_string(p
);
1047 } else if(verbose
) {
1048 error(ERR_WARNING
|ERR_PASS1
, "unterminated string");
1049 /* Handling unterminated strings by UNV */
1052 } else if (p
[0] == '$' && p
[1] == '$') {
1053 type
= TOK_OTHER
; /* TOKEN_BASE */
1055 } else if (isnumstart(*p
)) {
1056 bool is_hex
= false;
1057 bool is_float
= false;
1073 if (!is_hex
&& (c
== 'e' || c
== 'E')) {
1075 if (*p
== '+' || *p
== '-') {
1077 * e can only be followed by +/- if it is either a
1078 * prefixed hex number or a floating-point number
1083 } else if (c
== 'H' || c
== 'h' || c
== 'X' || c
== 'x') {
1085 } else if (c
== 'P' || c
== 'p') {
1087 if (*p
== '+' || *p
== '-')
1089 } else if (isnumchar(c
) || c
== '_')
1090 ; /* just advance */
1091 else if (c
== '.') {
1093 * we need to deal with consequences of the legacy
1094 * parser, like "1.nolist" being two tokens
1095 * (TOK_NUMBER, TOK_ID) here; at least give it
1096 * a shot for now. In the future, we probably need
1097 * a flex-based scanner with proper pattern matching
1098 * to do it as well as it can be done. Nothing in
1099 * the world is going to help the person who wants
1100 * 0x123.p16 interpreted as two tokens, though.
1106 if (nasm_isdigit(*r
) || (is_hex
&& nasm_isxdigit(*r
)) ||
1107 (!is_hex
&& (*r
== 'e' || *r
== 'E')) ||
1108 (*r
== 'p' || *r
== 'P')) {
1112 break; /* Terminate the token */
1116 p
--; /* Point to first character beyond number */
1118 if (p
== line
+1 && *line
== '$') {
1119 type
= TOK_OTHER
; /* TOKEN_HERE */
1121 if (has_e
&& !is_hex
) {
1122 /* 1e13 is floating-point, but 1e13h is not */
1126 type
= is_float
? TOK_FLOAT
: TOK_NUMBER
;
1128 } else if (nasm_isspace(*p
)) {
1129 type
= TOK_WHITESPACE
;
1130 p
= nasm_skip_spaces(p
);
1132 * Whitespace just before end-of-line is discarded by
1133 * pretending it's a comment; whitespace just before a
1134 * comment gets lumped into the comment.
1136 if (!*p
|| *p
== ';') {
1141 } else if (*p
== ';') {
1147 * Anything else is an operator of some kind. We check
1148 * for all the double-character operators (>>, <<, //,
1149 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
1150 * else is a single-character operator.
1153 if ((p
[0] == '>' && p
[1] == '>') ||
1154 (p
[0] == '<' && p
[1] == '<') ||
1155 (p
[0] == '/' && p
[1] == '/') ||
1156 (p
[0] == '<' && p
[1] == '=') ||
1157 (p
[0] == '>' && p
[1] == '=') ||
1158 (p
[0] == '=' && p
[1] == '=') ||
1159 (p
[0] == '!' && p
[1] == '=') ||
1160 (p
[0] == '<' && p
[1] == '>') ||
1161 (p
[0] == '&' && p
[1] == '&') ||
1162 (p
[0] == '|' && p
[1] == '|') ||
1163 (p
[0] == '^' && p
[1] == '^')) {
1169 /* Handling unterminated string by UNV */
1172 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
1173 t->text[p-line] = *line;
1177 if (type
!= TOK_COMMENT
) {
1178 *tail
= t
= new_Token(NULL
, type
, line
, p
- line
);
1187 * this function allocates a new managed block of memory and
1188 * returns a pointer to the block. The managed blocks are
1189 * deleted only all at once by the delete_Blocks function.
1191 static void *new_Block(size_t size
)
1193 Blocks
*b
= &blocks
;
1195 /* first, get to the end of the linked list */
1199 /* now allocate the requested chunk */
1200 b
->chunk
= nasm_malloc(size
);
1202 /* now allocate a new block for the next request */
1203 b
->next
= nasm_zalloc(sizeof(Blocks
));
1209 * this function deletes all managed blocks of memory
1211 static void delete_Blocks(void)
1213 Blocks
*a
, *b
= &blocks
;
1216 * keep in mind that the first block, pointed to by blocks
1217 * is a static and not dynamically allocated, so we don't
1222 nasm_free(b
->chunk
);
1231 * this function creates a new Token and passes a pointer to it
1232 * back to the caller. It sets the type and text elements, and
1233 * also the a.mac and next elements to NULL.
1235 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
1236 const char *text
, int txtlen
)
1242 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
1243 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
1244 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
1245 freeTokens
[i
].next
= NULL
;
1248 freeTokens
= t
->next
;
1252 if (type
== TOK_WHITESPACE
|| !text
) {
1256 txtlen
= strlen(text
);
1257 t
->text
= nasm_malloc(txtlen
+1);
1258 memcpy(t
->text
, text
, txtlen
);
1259 t
->text
[txtlen
] = '\0';
1264 static Token
*copy_Token(Token
* tline
)
1266 Token
*t
, *tt
, *first
= NULL
, *prev
= NULL
;
1268 for (tt
= tline
; tt
!= NULL
; tt
= tt
->next
) {
1270 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
1271 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
1272 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
1273 freeTokens
[i
].next
= NULL
;
1276 freeTokens
= t
->next
;
1278 t
->text
= tt
->text
? nasm_strdup(tt
->text
) : NULL
;
1279 t
->a
.mac
= tt
->a
.mac
;
1280 t
->a
.len
= tt
->a
.len
;
1292 static Token
*delete_Token(Token
* t
)
1294 Token
*next
= t
->next
;
1296 t
->next
= freeTokens
;
1302 * Convert a line of tokens back into text.
1303 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1304 * will be transformed into ..@ctxnum.xxx
1306 static char *detoken(Token
* tlist
, bool expand_locals
)
1313 list_for_each(t
, tlist
) {
1314 if (t
->type
== TOK_PREPROC_ID
&& t
->text
[1] == '!') {
1319 if (*v
== '\'' || *v
== '\"' || *v
== '`') {
1320 size_t len
= nasm_unquote(v
, NULL
);
1321 size_t clen
= strlen(v
);
1324 error(ERR_NONFATAL
| ERR_PASS1
,
1325 "NUL character in %! string");
1331 char *p
= getenv(v
);
1333 error(ERR_NONFATAL
| ERR_PASS1
,
1334 "nonexistent environment variable `%s'", v
);
1337 t
->text
= nasm_strdup(p
);
1342 /* Expand local macros here and not during preprocessing */
1343 if (expand_locals
&&
1344 t
->type
== TOK_PREPROC_ID
&& t
->text
&&
1345 t
->text
[0] == '%' && t
->text
[1] == '$') {
1348 Context
*ctx
= get_ctx(t
->text
, &q
, false);
1351 snprintf(buffer
, sizeof(buffer
), "..@%"PRIu32
".", ctx
->number
);
1352 p
= nasm_strcat(buffer
, q
);
1358 /* Expand %? and %?? directives */
1359 if ((istk
->expansion
!= NULL
) &&
1360 ((t
->type
== TOK_PREPROC_Q
) ||
1361 (t
->type
== TOK_PREPROC_QQ
))) {
1363 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
){
1364 if (ei
->type
== EXP_MMACRO
) {
1366 if (t
->type
== TOK_PREPROC_Q
) {
1367 t
->text
= nasm_strdup(ei
->name
);
1369 t
->text
= nasm_strdup(ei
->def
->name
);
1376 if (t
->type
== TOK_WHITESPACE
)
1379 len
+= strlen(t
->text
);
1382 p
= line
= nasm_malloc(len
+ 1);
1384 list_for_each(t
, tlist
) {
1385 if (t
->type
== TOK_WHITESPACE
) {
1387 } else if (t
->text
) {
1399 * Initialize a new Line
1401 static inline Line
*new_Line(void)
1403 return (Line
*)nasm_zalloc(sizeof(Line
));
1408 * Initialize a new Expansion Definition
1410 static ExpDef
*new_ExpDef(int exp_type
)
1412 ExpDef
*ed
= (ExpDef
*)nasm_zalloc(sizeof(ExpDef
));
1413 ed
->type
= exp_type
;
1414 ed
->casesense
= true;
1415 ed
->state
= COND_NEVER
;
1422 * Initialize a new Expansion Instance
1424 static ExpInv
*new_ExpInv(int exp_type
, ExpDef
*ed
)
1426 ExpInv
*ei
= (ExpInv
*)nasm_zalloc(sizeof(ExpInv
));
1427 ei
->type
= exp_type
;
1429 ei
->unique
= ++unique
;
1431 if ((istk
->mmac_depth
< 1) &&
1432 (istk
->expansion
== NULL
) &&
1434 (ed
->type
!= EXP_MMACRO
) &&
1435 (ed
->type
!= EXP_REP
) &&
1436 (ed
->type
!= EXP_WHILE
)) {
1437 ei
->linnum
= src_get_linnum();
1438 src_set_linnum(ei
->linnum
- ed
->linecount
- 1);
1442 if ((istk
->expansion
== NULL
) ||
1443 (ei
->type
== EXP_MMACRO
)) {
1446 ei
->relno
= istk
->expansion
->lineno
;
1448 ei
->relno
-= (ed
->linecount
+ 1);
1455 * A scanner, suitable for use by the expression evaluator, which
1456 * operates on a line of Tokens. Expects a pointer to a pointer to
1457 * the first token in the line to be passed in as its private_data
1460 * FIX: This really needs to be unified with stdscan.
1462 static int ppscan(void *private_data
, struct tokenval
*tokval
)
1464 Token
**tlineptr
= private_data
;
1466 char ourcopy
[MAX_KEYWORD
+1], *p
, *r
, *s
;
1470 *tlineptr
= tline
? tline
->next
: NULL
;
1471 } while (tline
&& (tline
->type
== TOK_WHITESPACE
||
1472 tline
->type
== TOK_COMMENT
));
1475 return tokval
->t_type
= TOKEN_EOS
;
1477 tokval
->t_charptr
= tline
->text
;
1479 if (tline
->text
[0] == '$' && !tline
->text
[1])
1480 return tokval
->t_type
= TOKEN_HERE
;
1481 if (tline
->text
[0] == '$' && tline
->text
[1] == '$' && !tline
->text
[2])
1482 return tokval
->t_type
= TOKEN_BASE
;
1484 if (tline
->type
== TOK_ID
) {
1485 p
= tokval
->t_charptr
= tline
->text
;
1487 tokval
->t_charptr
++;
1488 return tokval
->t_type
= TOKEN_ID
;
1491 for (r
= p
, s
= ourcopy
; *r
; r
++) {
1492 if (r
>= p
+MAX_KEYWORD
)
1493 return tokval
->t_type
= TOKEN_ID
; /* Not a keyword */
1494 *s
++ = nasm_tolower(*r
);
1497 /* right, so we have an identifier sitting in temp storage. now,
1498 * is it actually a register or instruction name, or what? */
1499 return nasm_token_hash(ourcopy
, tokval
);
1502 if (tline
->type
== TOK_NUMBER
) {
1504 tokval
->t_integer
= readnum(tline
->text
, &rn_error
);
1505 tokval
->t_charptr
= tline
->text
;
1507 return tokval
->t_type
= TOKEN_ERRNUM
;
1509 return tokval
->t_type
= TOKEN_NUM
;
1512 if (tline
->type
== TOK_FLOAT
) {
1513 return tokval
->t_type
= TOKEN_FLOAT
;
1516 if (tline
->type
== TOK_STRING
) {
1519 bq
= tline
->text
[0];
1520 tokval
->t_charptr
= tline
->text
;
1521 tokval
->t_inttwo
= nasm_unquote(tline
->text
, &ep
);
1523 if (ep
[0] != bq
|| ep
[1] != '\0')
1524 return tokval
->t_type
= TOKEN_ERRSTR
;
1526 return tokval
->t_type
= TOKEN_STR
;
1529 if (tline
->type
== TOK_OTHER
) {
1530 if (!strcmp(tline
->text
, "<<"))
1531 return tokval
->t_type
= TOKEN_SHL
;
1532 if (!strcmp(tline
->text
, ">>"))
1533 return tokval
->t_type
= TOKEN_SHR
;
1534 if (!strcmp(tline
->text
, "//"))
1535 return tokval
->t_type
= TOKEN_SDIV
;
1536 if (!strcmp(tline
->text
, "%%"))
1537 return tokval
->t_type
= TOKEN_SMOD
;
1538 if (!strcmp(tline
->text
, "=="))
1539 return tokval
->t_type
= TOKEN_EQ
;
1540 if (!strcmp(tline
->text
, "<>"))
1541 return tokval
->t_type
= TOKEN_NE
;
1542 if (!strcmp(tline
->text
, "!="))
1543 return tokval
->t_type
= TOKEN_NE
;
1544 if (!strcmp(tline
->text
, "<="))
1545 return tokval
->t_type
= TOKEN_LE
;
1546 if (!strcmp(tline
->text
, ">="))
1547 return tokval
->t_type
= TOKEN_GE
;
1548 if (!strcmp(tline
->text
, "&&"))
1549 return tokval
->t_type
= TOKEN_DBL_AND
;
1550 if (!strcmp(tline
->text
, "^^"))
1551 return tokval
->t_type
= TOKEN_DBL_XOR
;
1552 if (!strcmp(tline
->text
, "||"))
1553 return tokval
->t_type
= TOKEN_DBL_OR
;
1557 * We have no other options: just return the first character of
1560 return tokval
->t_type
= tline
->text
[0];
1564 * Compare a string to the name of an existing macro; this is a
1565 * simple wrapper which calls either strcmp or nasm_stricmp
1566 * depending on the value of the `casesense' parameter.
1568 static int mstrcmp(const char *p
, const char *q
, bool casesense
)
1570 return casesense
? strcmp(p
, q
) : nasm_stricmp(p
, q
);
1574 * Compare a string to the name of an existing macro; this is a
1575 * simple wrapper which calls either strcmp or nasm_stricmp
1576 * depending on the value of the `casesense' parameter.
1578 static int mmemcmp(const char *p
, const char *q
, size_t l
, bool casesense
)
1580 return casesense
? memcmp(p
, q
, l
) : nasm_memicmp(p
, q
, l
);
1584 * Return the Context structure associated with a %$ token. Return
1585 * NULL, having _already_ reported an error condition, if the
1586 * context stack isn't deep enough for the supplied number of $
1588 * If all_contexts == true, contexts that enclose current are
1589 * also scanned for such smacro, until it is found; if not -
1590 * only the context that directly results from the number of $'s
1591 * in variable's name.
1593 * If "namep" is non-NULL, set it to the pointer to the macro name
1594 * tail, i.e. the part beyond %$...
1596 static Context
*get_ctx(const char *name
, const char **namep
,
1606 if (!name
|| name
[0] != '%' || name
[1] != '$')
1610 error(ERR_NONFATAL
, "`%s': context stack is empty", name
);
1617 while (ctx
&& *name
== '$') {
1623 error(ERR_NONFATAL
, "`%s': context stack is only"
1624 " %d level%s deep", name
, i
, (i
== 1 ? "" : "s"));
1635 /* Search for this smacro in found context */
1636 m
= hash_findix(&ctx
->localmac
, name
);
1638 if (!mstrcmp(m
->name
, name
, m
->casesense
))
1649 * Check to see if a file is already in a string list
1651 static bool in_list(const StrList
*list
, const char *str
)
1654 if (!strcmp(list
->str
, str
))
1662 * Open an include file. This routine must always return a valid
1663 * file pointer if it returns - it's responsible for throwing an
1664 * ERR_FATAL and bombing out completely if not. It should also try
1665 * the include path one by one until it finds the file or reaches
1666 * the end of the path.
1668 static FILE *inc_fopen(const char *file
, StrList
**dhead
, StrList
***dtail
,
1673 IncPath
*ip
= ipath
;
1674 int len
= strlen(file
);
1675 size_t prefix_len
= 0;
1679 sl
= nasm_malloc(prefix_len
+len
+1+sizeof sl
->next
);
1681 memcpy(sl
->str
, prefix
, prefix_len
);
1682 memcpy(sl
->str
+prefix_len
, file
, len
+1);
1683 fp
= fopen(sl
->str
, "r");
1684 if (fp
&& dhead
&& !in_list(*dhead
, sl
->str
)) {
1701 prefix_len
= strlen(prefix
);
1703 /* -MG given and file not found */
1704 if (dhead
&& !in_list(*dhead
, file
)) {
1705 sl
= nasm_malloc(len
+1+sizeof sl
->next
);
1707 strcpy(sl
->str
, file
);
1715 error(ERR_FATAL
, "unable to open include file `%s'", file
);
1720 * Determine if we should warn on defining a single-line macro of
1721 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1722 * return true if _any_ single-line macro of that name is defined.
1723 * Otherwise, will return true if a single-line macro with either
1724 * `nparam' or no parameters is defined.
1726 * If a macro with precisely the right number of parameters is
1727 * defined, or nparam is -1, the address of the definition structure
1728 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1729 * is NULL, no action will be taken regarding its contents, and no
1732 * Note that this is also called with nparam zero to resolve
1735 * If you already know which context macro belongs to, you can pass
1736 * the context pointer as first parameter; if you won't but name begins
1737 * with %$ the context will be automatically computed. If all_contexts
1738 * is true, macro will be searched in outer contexts as well.
1741 smacro_defined(Context
* ctx
, const char *name
, int nparam
, SMacro
** defn
,
1744 struct hash_table
*smtbl
;
1748 smtbl
= &ctx
->localmac
;
1749 } else if (name
[0] == '%' && name
[1] == '$') {
1751 ctx
= get_ctx(name
, &name
, false);
1753 return false; /* got to return _something_ */
1754 smtbl
= &ctx
->localmac
;
1758 m
= (SMacro
*) hash_findix(smtbl
, name
);
1761 if (!mstrcmp(m
->name
, name
, m
->casesense
&& nocase
) &&
1762 (nparam
<= 0 || m
->nparam
== 0 || nparam
== (int) m
->nparam
)) {
1764 if (nparam
== (int) m
->nparam
|| nparam
== -1)
1778 * Count and mark off the parameters in a multi-line macro call.
1779 * This is called both from within the multi-line macro expansion
1780 * code, and also to mark off the default parameters when provided
1781 * in a %macro definition line.
1783 static void count_mmac_params(Token
* t
, int *nparam
, Token
*** params
)
1785 int paramsize
, brace
;
1787 *nparam
= paramsize
= 0;
1790 /* +1: we need space for the final NULL */
1791 if (*nparam
+1 >= paramsize
) {
1792 paramsize
+= PARAM_DELTA
;
1793 *params
= nasm_realloc(*params
, sizeof(**params
) * paramsize
);
1797 if (tok_is_(t
, "{"))
1799 (*params
)[(*nparam
)++] = t
;
1800 while (tok_isnt_(t
, brace
? "}" : ","))
1802 if (t
) { /* got a comma/brace */
1806 * Now we've found the closing brace, look further
1810 if (tok_isnt_(t
, ",")) {
1812 "braces do not enclose all of macro parameter");
1813 while (tok_isnt_(t
, ","))
1817 t
= t
->next
; /* eat the comma */
1824 * Determine whether one of the various `if' conditions is true or
1827 * We must free the tline we get passed.
1829 static bool if_condition(Token
* tline
, enum preproc_token ct
)
1831 enum pp_conditional i
= PP_COND(ct
);
1833 Token
*t
, *tt
, **tptr
, *origline
;
1834 struct tokenval tokval
;
1836 enum pp_token_type needtype
;
1843 j
= false; /* have we matched yet? */
1848 if (tline
->type
!= TOK_ID
) {
1850 "`%s' expects context identifiers", pp_directives
[ct
]);
1851 free_tlist(origline
);
1854 if (cstk
&& cstk
->name
&& !nasm_stricmp(tline
->text
, cstk
->name
))
1856 tline
= tline
->next
;
1861 j
= false; /* have we matched yet? */
1864 if (!tline
|| (tline
->type
!= TOK_ID
&&
1865 (tline
->type
!= TOK_PREPROC_ID
||
1866 tline
->text
[1] != '$'))) {
1868 "`%s' expects macro identifiers", pp_directives
[ct
]);
1871 if (smacro_defined(NULL
, tline
->text
, 0, NULL
, true))
1873 tline
= tline
->next
;
1878 tline
= expand_smacro(tline
);
1879 j
= false; /* have we matched yet? */
1882 if (!tline
|| (tline
->type
!= TOK_ID
&&
1883 tline
->type
!= TOK_STRING
&&
1884 (tline
->type
!= TOK_PREPROC_ID
||
1885 tline
->text
[1] != '!'))) {
1887 "`%s' expects environment variable names",
1892 if (tline
->type
== TOK_PREPROC_ID
)
1893 p
+= 2; /* Skip leading %! */
1894 if (*p
== '\'' || *p
== '\"' || *p
== '`')
1895 nasm_unquote_cstr(p
, ct
);
1898 tline
= tline
->next
;
1904 tline
= expand_smacro(tline
);
1906 while (tok_isnt_(tt
, ","))
1910 "`%s' expects two comma-separated arguments",
1915 j
= true; /* assume equality unless proved not */
1916 while ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) && tt
) {
1917 if (tt
->type
== TOK_OTHER
&& !strcmp(tt
->text
, ",")) {
1918 error(ERR_NONFATAL
, "`%s': more than one comma on line",
1922 if (t
->type
== TOK_WHITESPACE
) {
1926 if (tt
->type
== TOK_WHITESPACE
) {
1930 if (tt
->type
!= t
->type
) {
1931 j
= false; /* found mismatching tokens */
1934 /* When comparing strings, need to unquote them first */
1935 if (t
->type
== TOK_STRING
) {
1936 size_t l1
= nasm_unquote(t
->text
, NULL
);
1937 size_t l2
= nasm_unquote(tt
->text
, NULL
);
1943 if (mmemcmp(t
->text
, tt
->text
, l1
, i
== PPC_IFIDN
)) {
1947 } else if (mstrcmp(tt
->text
, t
->text
, i
== PPC_IFIDN
) != 0) {
1948 j
= false; /* found mismatching tokens */
1955 if ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) || tt
)
1956 j
= false; /* trailing gunk on one end or other */
1962 ExpDef searching
, *ed
;
1965 tline
= expand_id(tline
);
1966 if (!tok_type_(tline
, TOK_ID
)) {
1968 "`%s' expects a macro name", pp_directives
[ct
]);
1971 memset(&searching
, 0, sizeof(searching
));
1972 searching
.name
= nasm_strdup(tline
->text
);
1973 searching
.casesense
= true;
1974 searching
.nparam_max
= INT_MAX
;
1975 tline
= expand_smacro(tline
->next
);
1978 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
1980 "`%s' expects a parameter count or nothing",
1983 searching
.nparam_min
= searching
.nparam_max
=
1984 readnum(tline
->text
, &j
);
1987 "unable to parse parameter count `%s'",
1990 if (tline
&& tok_is_(tline
->next
, "-")) {
1991 tline
= tline
->next
->next
;
1992 if (tok_is_(tline
, "*"))
1993 searching
.nparam_max
= INT_MAX
;
1994 else if (!tok_type_(tline
, TOK_NUMBER
))
1996 "`%s' expects a parameter count after `-'",
1999 searching
.nparam_max
= readnum(tline
->text
, &j
);
2002 "unable to parse parameter count `%s'",
2004 if (searching
.nparam_min
> searching
.nparam_max
)
2006 "minimum parameter count exceeds maximum");
2009 if (tline
&& tok_is_(tline
->next
, "+")) {
2010 tline
= tline
->next
;
2011 searching
.plus
= true;
2013 ed
= (ExpDef
*) hash_findix(&expdefs
, searching
.name
);
2014 while (ed
!= NULL
) {
2015 if (!strcmp(ed
->name
, searching
.name
) &&
2016 (ed
->nparam_min
<= searching
.nparam_max
|| searching
.plus
) &&
2017 (searching
.nparam_min
<= ed
->nparam_max
|| ed
->plus
)) {
2023 if (tline
&& tline
->next
)
2024 error(ERR_WARNING
|ERR_PASS1
,
2025 "trailing garbage after %%ifmacro ignored");
2026 nasm_free(searching
.name
);
2035 needtype
= TOK_NUMBER
;
2038 needtype
= TOK_STRING
;
2042 t
= tline
= expand_smacro(tline
);
2044 while (tok_type_(t
, TOK_WHITESPACE
) ||
2045 (needtype
== TOK_NUMBER
&&
2046 tok_type_(t
, TOK_OTHER
) &&
2047 (t
->text
[0] == '-' || t
->text
[0] == '+') &&
2051 j
= tok_type_(t
, needtype
);
2055 t
= tline
= expand_smacro(tline
);
2056 while (tok_type_(t
, TOK_WHITESPACE
))
2061 t
= t
->next
; /* Skip the actual token */
2062 while (tok_type_(t
, TOK_WHITESPACE
))
2064 j
= !t
; /* Should be nothing left */
2069 t
= tline
= expand_smacro(tline
);
2070 while (tok_type_(t
, TOK_WHITESPACE
))
2073 j
= !t
; /* Should be empty */
2077 t
= tline
= expand_smacro(tline
);
2079 tokval
.t_type
= TOKEN_INVALID
;
2080 evalresult
= evaluate(ppscan
, tptr
, &tokval
,
2081 NULL
, pass
| CRITICAL
, error
, NULL
);
2085 error(ERR_WARNING
|ERR_PASS1
,
2086 "trailing garbage after expression ignored");
2087 if (!is_simple(evalresult
)) {
2089 "non-constant value given to `%s'", pp_directives
[ct
]);
2092 j
= reloc_value(evalresult
) != 0;
2097 "preprocessor directive `%s' not yet implemented",
2102 free_tlist(origline
);
2103 return j
^ PP_NEGATIVE(ct
);
2106 free_tlist(origline
);
2111 * Common code for defining an smacro
2113 static bool define_smacro(Context
*ctx
, const char *mname
, bool casesense
,
2114 int nparam
, Token
*expansion
)
2116 SMacro
*smac
, **smhead
;
2117 struct hash_table
*smtbl
;
2119 if (smacro_defined(ctx
, mname
, nparam
, &smac
, casesense
)) {
2121 error(ERR_WARNING
|ERR_PASS1
,
2122 "single-line macro `%s' defined both with and"
2123 " without parameters", mname
);
2125 * Some instances of the old code considered this a failure,
2126 * some others didn't. What is the right thing to do here?
2128 free_tlist(expansion
);
2129 return false; /* Failure */
2132 * We're redefining, so we have to take over an
2133 * existing SMacro structure. This means freeing
2134 * what was already in it.
2136 nasm_free(smac
->name
);
2137 free_tlist(smac
->expansion
);
2140 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
2141 smhead
= (SMacro
**) hash_findi_add(smtbl
, mname
);
2142 smac
= nasm_zalloc(sizeof(SMacro
));
2143 smac
->next
= *smhead
;
2146 smac
->name
= nasm_strdup(mname
);
2147 smac
->casesense
= casesense
;
2148 smac
->nparam
= nparam
;
2149 smac
->expansion
= expansion
;
2150 smac
->in_progress
= false;
2151 return true; /* Success */
2155 * Undefine an smacro
2157 static void undef_smacro(Context
*ctx
, const char *mname
)
2159 SMacro
**smhead
, *s
, **sp
;
2160 struct hash_table
*smtbl
;
2162 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
2163 smhead
= (SMacro
**)hash_findi(smtbl
, mname
, NULL
);
2167 * We now have a macro name... go hunt for it.
2170 while ((s
= *sp
) != NULL
) {
2171 if (!mstrcmp(s
->name
, mname
, s
->casesense
)) {
2174 free_tlist(s
->expansion
);
2184 * Parse a mmacro specification.
2186 static bool parse_mmacro_spec(Token
*tline
, ExpDef
*def
, const char *directive
)
2190 tline
= tline
->next
;
2192 tline
= expand_id(tline
);
2193 if (!tok_type_(tline
, TOK_ID
)) {
2194 error(ERR_NONFATAL
, "`%s' expects a macro name", directive
);
2198 def
->name
= nasm_strdup(tline
->text
);
2200 def
->nolist
= false;
2201 // def->in_progress = 0;
2202 // def->rep_nest = NULL;
2203 def
->nparam_min
= 0;
2204 def
->nparam_max
= 0;
2206 tline
= expand_smacro(tline
->next
);
2208 if (!tok_type_(tline
, TOK_NUMBER
)) {
2209 error(ERR_NONFATAL
, "`%s' expects a parameter count", directive
);
2211 def
->nparam_min
= def
->nparam_max
=
2212 readnum(tline
->text
, &err
);
2215 "unable to parse parameter count `%s'", tline
->text
);
2217 if (tline
&& tok_is_(tline
->next
, "-")) {
2218 tline
= tline
->next
->next
;
2219 if (tok_is_(tline
, "*")) {
2220 def
->nparam_max
= INT_MAX
;
2221 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
2223 "`%s' expects a parameter count after `-'", directive
);
2225 def
->nparam_max
= readnum(tline
->text
, &err
);
2227 error(ERR_NONFATAL
, "unable to parse parameter count `%s'",
2230 if (def
->nparam_min
> def
->nparam_max
) {
2231 error(ERR_NONFATAL
, "minimum parameter count exceeds maximum");
2235 if (tline
&& tok_is_(tline
->next
, "+")) {
2236 tline
= tline
->next
;
2239 if (tline
&& tok_type_(tline
->next
, TOK_ID
) &&
2240 !nasm_stricmp(tline
->next
->text
, ".nolist")) {
2241 tline
= tline
->next
;
2246 * Handle default parameters.
2248 if (tline
&& tline
->next
) {
2249 def
->dlist
= tline
->next
;
2251 count_mmac_params(def
->dlist
, &def
->ndefs
, &def
->defaults
);
2254 def
->defaults
= NULL
;
2258 if (def
->defaults
&& def
->ndefs
> def
->nparam_max
- def
->nparam_min
&&
2260 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MDP
,
2261 "too many default macro parameters");
2268 * Decode a size directive
2270 static int parse_size(const char *str
) {
2271 static const char *size_names
[] =
2272 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
2273 static const int sizes
[] =
2274 { 0, 1, 4, 16, 8, 10, 2, 32 };
2276 return sizes
[bsii(str
, size_names
, ARRAY_SIZE(size_names
))+1];
2280 * find and process pragma directive in passed line
2281 * Find out if a line contains a pragma directive, and deal
2284 * @param tline a pointer to the current tokeninzed line linked list
2285 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
2288 static int do_pragma(Token
* tline
)
2290 enum pragma_token i
;
2292 i
= pr_token_hash(tline
->text
);
2296 error(ERR_NONFATAL
, "unknown pragma directive `%s'",
2298 return NO_DIRECTIVE_FOUND
; /* didn't get it */
2302 "pragma directive `%s' not yet implemented",
2304 return DIRECTIVE_FOUND
;
2310 * find and process preprocessor directive in passed line
2311 * Find out if a line contains a preprocessor directive, and deal
2314 * If a directive _is_ found, it is the responsibility of this routine
2315 * (and not the caller) to free_tlist() the line.
2317 * @param tline a pointer to the current tokeninzed line linked list
2318 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
2321 static int do_directive(Token
* tline
)
2323 enum preproc_token i
;
2336 Token
*t
, *tt
, *param_start
, *macro_start
, *last
, **tptr
, *origline
;
2337 struct tokenval tokval
;
2339 ExpDef
*ed
, *eed
, **edhead
;
2348 if (!tline
|| !tok_type_(tline
, TOK_PREPROC_ID
) ||
2349 (tline
->text
[1] == '%' || tline
->text
[1] == '$'
2350 || tline
->text
[1] == '!'))
2351 return NO_DIRECTIVE_FOUND
;
2353 i
= pp_token_hash(tline
->text
);
2357 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2358 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
2360 return NO_DIRECTIVE_FOUND
; /* didn't get it */
2363 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2364 /* Directive to tell NASM what the default stack size is. The
2365 * default is for a 16-bit stack, and this can be overriden with
2368 tline
= tline
->next
;
2369 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2370 tline
= tline
->next
;
2371 if (!tline
|| tline
->type
!= TOK_ID
) {
2372 error(ERR_NONFATAL
, "`%%stacksize' missing size parameter");
2373 free_tlist(origline
);
2374 return DIRECTIVE_FOUND
;
2376 if (nasm_stricmp(tline
->text
, "flat") == 0) {
2377 /* All subsequent ARG directives are for a 32-bit stack */
2379 StackPointer
= "ebp";
2382 } else if (nasm_stricmp(tline
->text
, "flat64") == 0) {
2383 /* All subsequent ARG directives are for a 64-bit stack */
2385 StackPointer
= "rbp";
2388 } else if (nasm_stricmp(tline
->text
, "large") == 0) {
2389 /* All subsequent ARG directives are for a 16-bit stack,
2390 * far function call.
2393 StackPointer
= "bp";
2396 } else if (nasm_stricmp(tline
->text
, "small") == 0) {
2397 /* All subsequent ARG directives are for a 16-bit stack,
2398 * far function call. We don't support near functions.
2401 StackPointer
= "bp";
2405 error(ERR_NONFATAL
, "`%%stacksize' invalid size type");
2406 free_tlist(origline
);
2407 return DIRECTIVE_FOUND
;
2409 free_tlist(origline
);
2410 return DIRECTIVE_FOUND
;
2413 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2414 /* TASM like ARG directive to define arguments to functions, in
2415 * the following form:
2417 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2421 char *arg
, directive
[256];
2422 int size
= StackSize
;
2424 /* Find the argument name */
2425 tline
= tline
->next
;
2426 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2427 tline
= tline
->next
;
2428 if (!tline
|| tline
->type
!= TOK_ID
) {
2429 error(ERR_NONFATAL
, "`%%arg' missing argument parameter");
2430 free_tlist(origline
);
2431 return DIRECTIVE_FOUND
;
2435 /* Find the argument size type */
2436 tline
= tline
->next
;
2437 if (!tline
|| tline
->type
!= TOK_OTHER
2438 || tline
->text
[0] != ':') {
2440 "Syntax error processing `%%arg' directive");
2441 free_tlist(origline
);
2442 return DIRECTIVE_FOUND
;
2444 tline
= tline
->next
;
2445 if (!tline
|| tline
->type
!= TOK_ID
) {
2446 error(ERR_NONFATAL
, "`%%arg' missing size type parameter");
2447 free_tlist(origline
);
2448 return DIRECTIVE_FOUND
;
2451 /* Allow macro expansion of type parameter */
2452 tt
= tokenize(tline
->text
);
2453 tt
= expand_smacro(tt
);
2454 size
= parse_size(tt
->text
);
2457 "Invalid size type for `%%arg' missing directive");
2459 free_tlist(origline
);
2460 return DIRECTIVE_FOUND
;
2464 /* Round up to even stack slots */
2465 size
= ALIGN(size
, StackSize
);
2467 /* Now define the macro for the argument */
2468 snprintf(directive
, sizeof(directive
), "%%define %s (%s+%d)",
2469 arg
, StackPointer
, offset
);
2470 do_directive(tokenize(directive
));
2473 /* Move to the next argument in the list */
2474 tline
= tline
->next
;
2475 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2476 tline
= tline
->next
;
2477 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2479 free_tlist(origline
);
2480 return DIRECTIVE_FOUND
;
2483 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2484 /* TASM like LOCAL directive to define local variables for a
2485 * function, in the following form:
2487 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2489 * The '= LocalSize' at the end is ignored by NASM, but is
2490 * required by TASM to define the local parameter size (and used
2491 * by the TASM macro package).
2493 offset
= LocalOffset
;
2495 char *local
, directive
[256];
2496 int size
= StackSize
;
2498 /* Find the argument name */
2499 tline
= tline
->next
;
2500 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2501 tline
= tline
->next
;
2502 if (!tline
|| tline
->type
!= TOK_ID
) {
2504 "`%%local' missing argument parameter");
2505 free_tlist(origline
);
2506 return DIRECTIVE_FOUND
;
2508 local
= tline
->text
;
2510 /* Find the argument size type */
2511 tline
= tline
->next
;
2512 if (!tline
|| tline
->type
!= TOK_OTHER
2513 || tline
->text
[0] != ':') {
2515 "Syntax error processing `%%local' directive");
2516 free_tlist(origline
);
2517 return DIRECTIVE_FOUND
;
2519 tline
= tline
->next
;
2520 if (!tline
|| tline
->type
!= TOK_ID
) {
2522 "`%%local' missing size type parameter");
2523 free_tlist(origline
);
2524 return DIRECTIVE_FOUND
;
2527 /* Allow macro expansion of type parameter */
2528 tt
= tokenize(tline
->text
);
2529 tt
= expand_smacro(tt
);
2530 size
= parse_size(tt
->text
);
2533 "Invalid size type for `%%local' missing directive");
2535 free_tlist(origline
);
2536 return DIRECTIVE_FOUND
;
2540 /* Round up to even stack slots */
2541 size
= ALIGN(size
, StackSize
);
2543 offset
+= size
; /* Negative offset, increment before */
2545 /* Now define the macro for the argument */
2546 snprintf(directive
, sizeof(directive
), "%%define %s (%s-%d)",
2547 local
, StackPointer
, offset
);
2548 do_directive(tokenize(directive
));
2550 /* Now define the assign to setup the enter_c macro correctly */
2551 snprintf(directive
, sizeof(directive
),
2552 "%%assign %%$localsize %%$localsize+%d", size
);
2553 do_directive(tokenize(directive
));
2555 /* Move to the next argument in the list */
2556 tline
= tline
->next
;
2557 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2558 tline
= tline
->next
;
2559 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2560 LocalOffset
= offset
;
2561 free_tlist(origline
);
2562 return DIRECTIVE_FOUND
;
2565 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2567 error(ERR_WARNING
|ERR_PASS1
,
2568 "trailing garbage after `%%clear' ignored");
2571 free_tlist(origline
);
2572 return DIRECTIVE_FOUND
;
2575 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2576 t
= tline
->next
= expand_smacro(tline
->next
);
2578 if (!t
|| (t
->type
!= TOK_STRING
&&
2579 t
->type
!= TOK_INTERNAL_STRING
)) {
2580 error(ERR_NONFATAL
, "`%%depend' expects a file name");
2581 free_tlist(origline
);
2582 return DIRECTIVE_FOUND
; /* but we did _something_ */
2585 error(ERR_WARNING
|ERR_PASS1
,
2586 "trailing garbage after `%%depend' ignored");
2588 if (t
->type
!= TOK_INTERNAL_STRING
)
2589 nasm_unquote_cstr(p
, i
);
2590 if (dephead
&& !in_list(*dephead
, p
)) {
2591 StrList
*sl
= nasm_malloc(strlen(p
)+1+sizeof sl
->next
);
2595 deptail
= &sl
->next
;
2597 free_tlist(origline
);
2598 return DIRECTIVE_FOUND
;
2601 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2602 t
= tline
->next
= expand_smacro(tline
->next
);
2605 if (!t
|| (t
->type
!= TOK_STRING
&&
2606 t
->type
!= TOK_INTERNAL_STRING
)) {
2607 error(ERR_NONFATAL
, "`%%include' expects a file name");
2608 free_tlist(origline
);
2609 return DIRECTIVE_FOUND
; /* but we did _something_ */
2612 error(ERR_WARNING
|ERR_PASS1
,
2613 "trailing garbage after `%%include' ignored");
2615 if (t
->type
!= TOK_INTERNAL_STRING
)
2616 nasm_unquote_cstr(p
, i
);
2617 inc
= nasm_zalloc(sizeof(Include
));
2619 inc
->fp
= inc_fopen(p
, dephead
, &deptail
, pass
== 0);
2621 /* -MG given but file not found */
2624 inc
->fname
= src_set_fname(nasm_strdup(p
));
2625 inc
->lineno
= src_set_linnum(0);
2627 inc
->expansion
= NULL
;
2629 list
->uplevel(LIST_INCLUDE
);
2631 free_tlist(origline
);
2632 return DIRECTIVE_FOUND
;
2635 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2637 static macros_t
*use_pkg
;
2638 const char *pkg_macro
= NULL
;
2640 tline
= tline
->next
;
2642 tline
= expand_id(tline
);
2644 if (!tline
|| (tline
->type
!= TOK_STRING
&&
2645 tline
->type
!= TOK_INTERNAL_STRING
&&
2646 tline
->type
!= TOK_ID
)) {
2647 error(ERR_NONFATAL
, "`%%use' expects a package name");
2648 free_tlist(origline
);
2649 return DIRECTIVE_FOUND
; /* but we did _something_ */
2652 error(ERR_WARNING
|ERR_PASS1
,
2653 "trailing garbage after `%%use' ignored");
2654 if (tline
->type
== TOK_STRING
)
2655 nasm_unquote_cstr(tline
->text
, i
);
2656 use_pkg
= nasm_stdmac_find_package(tline
->text
);
2658 error(ERR_NONFATAL
, "unknown `%%use' package: %s", tline
->text
);
2660 pkg_macro
= (char *)use_pkg
+ 1; /* The first string will be <%define>__USE_*__ */
2661 if (use_pkg
&& ! smacro_defined(NULL
, pkg_macro
, 0, NULL
, true)) {
2662 /* Not already included, go ahead and include it */
2663 stdmacpos
= use_pkg
;
2665 free_tlist(origline
);
2666 return DIRECTIVE_FOUND
;
2671 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2672 tline
= tline
->next
;
2674 tline
= expand_id(tline
);
2676 if (!tok_type_(tline
, TOK_ID
)) {
2677 error(ERR_NONFATAL
, "`%s' expects a context identifier",
2679 free_tlist(origline
);
2680 return DIRECTIVE_FOUND
; /* but we did _something_ */
2683 error(ERR_WARNING
|ERR_PASS1
,
2684 "trailing garbage after `%s' ignored",
2686 p
= nasm_strdup(tline
->text
);
2688 p
= NULL
; /* Anonymous */
2692 ctx
= nasm_zalloc(sizeof(Context
));
2694 hash_init(&ctx
->localmac
, HASH_SMALL
);
2696 ctx
->number
= unique
++;
2701 error(ERR_NONFATAL
, "`%s': context stack is empty",
2703 } else if (i
== PP_POP
) {
2704 if (p
&& (!cstk
->name
|| nasm_stricmp(p
, cstk
->name
)))
2705 error(ERR_NONFATAL
, "`%%pop' in wrong context: %s, "
2707 cstk
->name
? cstk
->name
: "anonymous", p
);
2712 nasm_free(cstk
->name
);
2718 free_tlist(origline
);
2719 return DIRECTIVE_FOUND
;
2721 severity
= ERR_FATAL
;
2724 severity
= ERR_NONFATAL
;
2727 severity
= ERR_WARNING
|ERR_WARN_USER
;
2731 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2733 /* Only error out if this is the final pass */
2734 if (pass
!= 2 && i
!= PP_FATAL
)
2735 return DIRECTIVE_FOUND
;
2737 tline
->next
= expand_smacro(tline
->next
);
2738 tline
= tline
->next
;
2740 t
= tline
? tline
->next
: NULL
;
2742 if (tok_type_(tline
, TOK_STRING
) && !t
) {
2743 /* The line contains only a quoted string */
2745 nasm_unquote(p
, NULL
); /* Ignore NUL character truncation */
2746 error(severity
, "%s", p
);
2748 /* Not a quoted string, or more than a quoted string */
2749 p
= detoken(tline
, false);
2750 error(severity
, "%s", p
);
2753 free_tlist(origline
);
2754 return DIRECTIVE_FOUND
;
2758 if (defining
!= NULL
) {
2759 if (defining
->type
== EXP_IF
) {
2760 defining
->def_depth
++;
2762 return NO_DIRECTIVE_FOUND
;
2764 if ((istk
->expansion
!= NULL
) &&
2765 (istk
->expansion
->emitting
== false)) {
2768 j
= if_condition(tline
->next
, i
);
2769 tline
->next
= NULL
; /* it got freed */
2770 j
= (((j
< 0) ? COND_NEVER
: j
) ? COND_IF_TRUE
: COND_IF_FALSE
);
2772 ed
= new_ExpDef(EXP_IF
);
2778 ed
->ignoring
= ((ed
->state
== COND_IF_TRUE
) ? false : true);
2779 ed
->prev
= defining
;
2781 free_tlist(origline
);
2782 return DIRECTIVE_FOUND
;
2785 if (defining
!= NULL
) {
2786 if ((defining
->type
!= EXP_IF
) || (defining
->def_depth
> 0)) {
2787 return NO_DIRECTIVE_FOUND
;
2790 if ((defining
== NULL
) || (defining
->type
!= EXP_IF
)) {
2791 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2793 switch (defining
->state
) {
2795 defining
->state
= COND_DONE
;
2796 defining
->ignoring
= true;
2801 defining
->ignoring
= true;
2804 case COND_ELSE_TRUE
:
2805 case COND_ELSE_FALSE
:
2806 error_precond(ERR_WARNING
|ERR_PASS1
,
2807 "`%%elif' after `%%else' ignored");
2808 defining
->state
= COND_NEVER
;
2809 defining
->ignoring
= true;
2814 * IMPORTANT: In the case of %if, we will already have
2815 * called expand_mmac_params(); however, if we're
2816 * processing an %elif we must have been in a
2817 * non-emitting mode, which would have inhibited
2818 * the normal invocation of expand_mmac_params().
2819 * Therefore, we have to do it explicitly here.
2821 j
= if_condition(expand_mmac_params(tline
->next
), i
);
2822 tline
->next
= NULL
; /* it got freed */
2824 j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2825 defining
->ignoring
= ((defining
->state
== COND_IF_TRUE
) ? false : true);
2828 free_tlist(origline
);
2829 return DIRECTIVE_FOUND
;
2832 if (defining
!= NULL
) {
2833 if ((defining
->type
!= EXP_IF
) || (defining
->def_depth
> 0)) {
2834 return NO_DIRECTIVE_FOUND
;
2838 error_precond(ERR_WARNING
|ERR_PASS1
,
2839 "trailing garbage after `%%else' ignored");
2840 if ((defining
== NULL
) || (defining
->type
!= EXP_IF
)) {
2841 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2843 switch (defining
->state
) {
2846 defining
->state
= COND_ELSE_FALSE
;
2847 defining
->ignoring
= true;
2851 defining
->ignoring
= true;
2855 defining
->state
= COND_ELSE_TRUE
;
2856 defining
->ignoring
= false;
2859 case COND_ELSE_TRUE
:
2860 case COND_ELSE_FALSE
:
2861 error_precond(ERR_WARNING
|ERR_PASS1
,
2862 "`%%else' after `%%else' ignored.");
2863 defining
->state
= COND_NEVER
;
2864 defining
->ignoring
= true;
2867 free_tlist(origline
);
2868 return DIRECTIVE_FOUND
;
2871 if (defining
!= NULL
) {
2872 if (defining
->type
== EXP_IF
) {
2873 if (defining
->def_depth
> 0) {
2874 defining
->def_depth
--;
2875 return NO_DIRECTIVE_FOUND
;
2878 return NO_DIRECTIVE_FOUND
;
2882 error_precond(ERR_WARNING
|ERR_PASS1
,
2883 "trailing garbage after `%%endif' ignored");
2884 if ((defining
== NULL
) || (defining
->type
!= EXP_IF
)) {
2885 error(ERR_NONFATAL
, "`%%endif': no matching `%%if'");
2886 return DIRECTIVE_FOUND
;
2889 defining
= ed
->prev
;
2890 ed
->prev
= expansions
;
2892 ei
= new_ExpInv(EXP_IF
, ed
);
2893 ei
->current
= ed
->line
;
2894 ei
->emitting
= true;
2895 ei
->prev
= istk
->expansion
;
2896 istk
->expansion
= ei
;
2897 free_tlist(origline
);
2898 return DIRECTIVE_FOUND
;
2904 if (defining
!= NULL
) {
2905 if (defining
->type
== EXP_MMACRO
) {
2906 defining
->def_depth
++;
2908 return NO_DIRECTIVE_FOUND
;
2910 ed
= new_ExpDef(EXP_MMACRO
);
2912 (i
== PP_RMACRO
) || (i
== PP_IRMACRO
) ? DEADMAN_LIMIT
: 0;
2913 ed
->casesense
= (i
== PP_MACRO
) || (i
== PP_RMACRO
);
2914 if (!parse_mmacro_spec(tline
, ed
, pp_directives
[i
])) {
2917 return DIRECTIVE_FOUND
;
2921 ed
->max_depth
= (ed
->max_depth
+ 1);
2922 ed
->ignoring
= false;
2923 ed
->prev
= defining
;
2926 eed
= (ExpDef
*) hash_findix(&expdefs
, ed
->name
);
2928 if (!strcmp(eed
->name
, ed
->name
) &&
2929 (eed
->nparam_min
<= ed
->nparam_max
|| ed
->plus
) &&
2930 (ed
->nparam_min
<= eed
->nparam_max
|| eed
->plus
)) {
2931 error(ERR_WARNING
|ERR_PASS1
,
2932 "redefining multi-line macro `%s'", ed
->name
);
2933 return DIRECTIVE_FOUND
;
2937 free_tlist(origline
);
2938 return DIRECTIVE_FOUND
;
2942 if (defining
!= NULL
) {
2943 if (defining
->type
== EXP_MMACRO
) {
2944 if (defining
->def_depth
> 0) {
2945 defining
->def_depth
--;
2946 return NO_DIRECTIVE_FOUND
;
2949 return NO_DIRECTIVE_FOUND
;
2952 if (!(defining
) || (defining
->type
!= EXP_MMACRO
)) {
2953 error(ERR_NONFATAL
, "`%s': not defining a macro", tline
->text
);
2954 return DIRECTIVE_FOUND
;
2956 edhead
= (ExpDef
**) hash_findi_add(&expdefs
, defining
->name
);
2957 defining
->next
= *edhead
;
2960 defining
= ed
->prev
;
2961 ed
->prev
= expansions
;
2964 free_tlist(origline
);
2965 return DIRECTIVE_FOUND
;
2968 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2970 * We must search along istk->expansion until we hit a
2971 * macro invocation. Then we disable the emitting state(s)
2972 * between exitmacro and endmacro.
2974 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
2975 if(ei
->type
== EXP_MMACRO
) {
2982 * Set all invocations leading back to the macro
2983 * invocation to a non-emitting state.
2985 for (eei
= istk
->expansion
; eei
!= ei
; eei
= eei
->prev
) {
2986 eei
->emitting
= false;
2988 eei
->emitting
= false;
2990 error(ERR_NONFATAL
, "`%%exitmacro' not within `%%macro' block");
2992 free_tlist(origline
);
2993 return DIRECTIVE_FOUND
;
2997 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3002 spec
.casesense
= (i
== PP_UNMACRO
);
3003 if (!parse_mmacro_spec(tline
, &spec
, pp_directives
[i
])) {
3004 return DIRECTIVE_FOUND
;
3006 ed_p
= (ExpDef
**) hash_findi(&expdefs
, spec
.name
, NULL
);
3007 while (ed_p
&& *ed_p
) {
3009 if (ed
->casesense
== spec
.casesense
&&
3010 !mstrcmp(ed
->name
, spec
.name
, spec
.casesense
) &&
3011 ed
->nparam_min
== spec
.nparam_min
&&
3012 ed
->nparam_max
== spec
.nparam_max
&&
3013 ed
->plus
== spec
.plus
) {
3014 if (ed
->cur_depth
> 0) {
3015 error(ERR_NONFATAL
, "`%s' ignored on active macro",
3026 free_tlist(origline
);
3027 free_tlist(spec
.dlist
);
3028 return DIRECTIVE_FOUND
;
3032 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3033 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
3034 tline
= tline
->next
;
3036 free_tlist(origline
);
3037 error(ERR_NONFATAL
, "`%%rotate' missing rotate count");
3038 return DIRECTIVE_FOUND
;
3040 t
= expand_smacro(tline
->next
);
3042 free_tlist(origline
);
3045 tokval
.t_type
= TOKEN_INVALID
;
3047 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3050 return DIRECTIVE_FOUND
;
3052 error(ERR_WARNING
|ERR_PASS1
,
3053 "trailing garbage after expression ignored");
3054 if (!is_simple(evalresult
)) {
3055 error(ERR_NONFATAL
, "non-constant value given to `%%rotate'");
3056 return DIRECTIVE_FOUND
;
3058 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
3059 if (ei
->type
== EXP_MMACRO
) {
3064 error(ERR_NONFATAL
, "`%%rotate' invoked outside a macro call");
3065 } else if (ei
->nparam
== 0) {
3067 "`%%rotate' invoked within macro without parameters");
3069 int rotate
= ei
->rotate
+ reloc_value(evalresult
);
3071 rotate
%= (int)ei
->nparam
;
3073 rotate
+= ei
->nparam
;
3074 ei
->rotate
= rotate
;
3076 return DIRECTIVE_FOUND
;
3079 if (defining
!= NULL
) {
3080 if (defining
->type
== EXP_REP
) {
3081 defining
->def_depth
++;
3083 return NO_DIRECTIVE_FOUND
;
3087 tline
= tline
->next
;
3088 } while (tok_type_(tline
, TOK_WHITESPACE
));
3090 if (tok_type_(tline
, TOK_ID
) &&
3091 nasm_stricmp(tline
->text
, ".nolist") == 0) {
3094 tline
= tline
->next
;
3095 } while (tok_type_(tline
, TOK_WHITESPACE
));
3099 t
= expand_smacro(tline
);
3101 tokval
.t_type
= TOKEN_INVALID
;
3103 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3105 free_tlist(origline
);
3106 return DIRECTIVE_FOUND
;
3109 error(ERR_WARNING
|ERR_PASS1
,
3110 "trailing garbage after expression ignored");
3111 if (!is_simple(evalresult
)) {
3112 error(ERR_NONFATAL
, "non-constant value given to `%%rep'");
3113 return DIRECTIVE_FOUND
;
3115 count
= reloc_value(evalresult
);
3116 if (count
>= REP_LIMIT
) {
3117 error(ERR_NONFATAL
, "`%%rep' value exceeds limit");
3122 error(ERR_NONFATAL
, "`%%rep' expects a repeat count");
3125 free_tlist(origline
);
3126 ed
= new_ExpDef(EXP_REP
);
3127 ed
->nolist
= nolist
;
3130 ed
->max_depth
= (count
- 1);
3131 ed
->ignoring
= false;
3132 ed
->prev
= defining
;
3134 return DIRECTIVE_FOUND
;
3137 if (defining
!= NULL
) {
3138 if (defining
->type
== EXP_REP
) {
3139 if (defining
->def_depth
> 0) {
3140 defining
->def_depth
--;
3141 return NO_DIRECTIVE_FOUND
;
3144 return NO_DIRECTIVE_FOUND
;
3147 if ((defining
== NULL
) || (defining
->type
!= EXP_REP
)) {
3148 error(ERR_NONFATAL
, "`%%endrep': no matching `%%rep'");
3149 return DIRECTIVE_FOUND
;
3153 * Now we have a "macro" defined - although it has no name
3154 * and we won't be entering it in the hash tables - we must
3155 * push a macro-end marker for it on to istk->expansion.
3156 * After that, it will take care of propagating itself (a
3157 * macro-end marker line for a macro which is really a %rep
3158 * block will cause the macro to be re-expanded, complete
3159 * with another macro-end marker to ensure the process
3160 * continues) until the whole expansion is forcibly removed
3161 * from istk->expansion by a %exitrep.
3164 defining
= ed
->prev
;
3165 ed
->prev
= expansions
;
3167 ei
= new_ExpInv(EXP_REP
, ed
);
3168 ei
->current
= ed
->line
;
3169 ei
->emitting
= ((ed
->max_depth
> 0) ? true : false);
3170 list
->uplevel(ed
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
3171 ei
->prev
= istk
->expansion
;
3172 istk
->expansion
= ei
;
3173 free_tlist(origline
);
3174 return DIRECTIVE_FOUND
;
3177 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3179 * We must search along istk->expansion until we hit a
3180 * rep invocation. Then we disable the emitting state(s)
3181 * between exitrep and endrep.
3183 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
3184 if (ei
->type
== EXP_REP
) {
3191 * Set all invocations leading back to the rep
3192 * invocation to a non-emitting state.
3194 for (eei
= istk
->expansion
; eei
!= ei
; eei
= eei
->prev
) {
3195 eei
->emitting
= false;
3197 eei
->emitting
= false;
3198 eei
->current
= NULL
;
3199 eei
->def
->cur_depth
= eei
->def
->max_depth
;
3201 error(ERR_NONFATAL
, "`%%exitrep' not within `%%rep' block");
3203 free_tlist(origline
);
3204 return DIRECTIVE_FOUND
;
3210 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3211 casesense
= (i
== PP_DEFINE
|| i
== PP_XDEFINE
);
3213 tline
= tline
->next
;
3215 tline
= expand_id(tline
);
3216 if (!tline
|| (tline
->type
!= TOK_ID
&&
3217 (tline
->type
!= TOK_PREPROC_ID
||
3218 tline
->text
[1] != '$'))) {
3219 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
3221 free_tlist(origline
);
3222 return DIRECTIVE_FOUND
;
3225 ctx
= get_ctx(tline
->text
, &mname
, false);
3227 param_start
= tline
= tline
->next
;
3230 /* Expand the macro definition now for %xdefine and %ixdefine */
3231 if ((i
== PP_XDEFINE
) || (i
== PP_IXDEFINE
))
3232 tline
= expand_smacro(tline
);
3234 if (tok_is_(tline
, "(")) {
3236 * This macro has parameters.
3239 tline
= tline
->next
;
3243 error(ERR_NONFATAL
, "parameter identifier expected");
3244 free_tlist(origline
);
3245 return DIRECTIVE_FOUND
;
3247 if (tline
->type
!= TOK_ID
) {
3249 "`%s': parameter identifier expected",
3251 free_tlist(origline
);
3252 return DIRECTIVE_FOUND
;
3254 tline
->type
= TOK_SMAC_PARAM
+ nparam
++;
3255 tline
= tline
->next
;
3257 if (tok_is_(tline
, ",")) {
3258 tline
= tline
->next
;
3260 if (!tok_is_(tline
, ")")) {
3262 "`)' expected to terminate macro template");
3263 free_tlist(origline
);
3264 return DIRECTIVE_FOUND
;
3270 tline
= tline
->next
;
3272 if (tok_type_(tline
, TOK_WHITESPACE
))
3273 last
= tline
, tline
= tline
->next
;
3278 if (t
->type
== TOK_ID
) {
3279 list_for_each(tt
, param_start
)
3280 if (tt
->type
>= TOK_SMAC_PARAM
&&
3281 !strcmp(tt
->text
, t
->text
))
3285 t
->next
= macro_start
;
3290 * Good. We now have a macro name, a parameter count, and a
3291 * token list (in reverse order) for an expansion. We ought
3292 * to be OK just to create an SMacro, store it, and let
3293 * free_tlist have the rest of the line (which we have
3294 * carefully re-terminated after chopping off the expansion
3297 define_smacro(ctx
, mname
, casesense
, nparam
, macro_start
);
3298 free_tlist(origline
);
3299 return DIRECTIVE_FOUND
;
3302 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3303 tline
= tline
->next
;
3305 tline
= expand_id(tline
);
3306 if (!tline
|| (tline
->type
!= TOK_ID
&&
3307 (tline
->type
!= TOK_PREPROC_ID
||
3308 tline
->text
[1] != '$'))) {
3309 error(ERR_NONFATAL
, "`%%undef' expects a macro identifier");
3310 free_tlist(origline
);
3311 return DIRECTIVE_FOUND
;
3314 error(ERR_WARNING
|ERR_PASS1
,
3315 "trailing garbage after macro name ignored");
3318 /* Find the context that symbol belongs to */
3319 ctx
= get_ctx(tline
->text
, &mname
, false);
3320 undef_smacro(ctx
, mname
);
3321 free_tlist(origline
);
3322 return DIRECTIVE_FOUND
;
3326 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3327 casesense
= (i
== PP_DEFSTR
);
3329 tline
= tline
->next
;
3331 tline
= expand_id(tline
);
3332 if (!tline
|| (tline
->type
!= TOK_ID
&&
3333 (tline
->type
!= TOK_PREPROC_ID
||
3334 tline
->text
[1] != '$'))) {
3335 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
3337 free_tlist(origline
);
3338 return DIRECTIVE_FOUND
;
3341 ctx
= get_ctx(tline
->text
, &mname
, false);
3343 tline
= expand_smacro(tline
->next
);
3346 while (tok_type_(tline
, TOK_WHITESPACE
))
3347 tline
= delete_Token(tline
);
3349 p
= detoken(tline
, false);
3350 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3351 macro_start
->text
= nasm_quote(p
, strlen(p
));
3352 macro_start
->type
= TOK_STRING
;
3356 * We now have a macro name, an implicit parameter count of
3357 * zero, and a string token to use as an expansion. Create
3358 * and store an SMacro.
3360 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3361 free_tlist(origline
);
3362 return DIRECTIVE_FOUND
;
3366 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3367 casesense
= (i
== PP_DEFTOK
);
3369 tline
= tline
->next
;
3371 tline
= expand_id(tline
);
3372 if (!tline
|| (tline
->type
!= TOK_ID
&&
3373 (tline
->type
!= TOK_PREPROC_ID
||
3374 tline
->text
[1] != '$'))) {
3376 "`%s' expects a macro identifier as first parameter",
3378 free_tlist(origline
);
3379 return DIRECTIVE_FOUND
;
3381 ctx
= get_ctx(tline
->text
, &mname
, false);
3383 tline
= expand_smacro(tline
->next
);
3387 while (tok_type_(t
, TOK_WHITESPACE
))
3389 /* t should now point to the string */
3390 if (!tok_type_(t
, TOK_STRING
)) {
3392 "`%s` requires string as second parameter",
3395 free_tlist(origline
);
3396 return DIRECTIVE_FOUND
;
3400 * Convert the string to a token stream. Note that smacros
3401 * are stored with the token stream reversed, so we have to
3402 * reverse the output of tokenize().
3404 nasm_unquote_cstr(t
->text
, i
);
3405 macro_start
= reverse_tokens(tokenize(t
->text
));
3408 * We now have a macro name, an implicit parameter count of
3409 * zero, and a numeric token to use as an expansion. Create
3410 * and store an SMacro.
3412 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3414 free_tlist(origline
);
3415 return DIRECTIVE_FOUND
;
3418 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3421 StrList
*xsl
= NULL
;
3422 StrList
**xst
= &xsl
;
3426 tline
= tline
->next
;
3428 tline
= expand_id(tline
);
3429 if (!tline
|| (tline
->type
!= TOK_ID
&&
3430 (tline
->type
!= TOK_PREPROC_ID
||
3431 tline
->text
[1] != '$'))) {
3433 "`%%pathsearch' expects a macro identifier as first parameter");
3434 free_tlist(origline
);
3435 return DIRECTIVE_FOUND
;
3437 ctx
= get_ctx(tline
->text
, &mname
, false);
3439 tline
= expand_smacro(tline
->next
);
3443 while (tok_type_(t
, TOK_WHITESPACE
))
3446 if (!t
|| (t
->type
!= TOK_STRING
&&
3447 t
->type
!= TOK_INTERNAL_STRING
)) {
3448 error(ERR_NONFATAL
, "`%%pathsearch' expects a file name");
3450 free_tlist(origline
);
3451 return DIRECTIVE_FOUND
; /* but we did _something_ */
3454 error(ERR_WARNING
|ERR_PASS1
,
3455 "trailing garbage after `%%pathsearch' ignored");
3457 if (t
->type
!= TOK_INTERNAL_STRING
)
3458 nasm_unquote(p
, NULL
);
3460 fp
= inc_fopen(p
, &xsl
, &xst
, true);
3463 fclose(fp
); /* Don't actually care about the file */
3465 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3466 macro_start
->text
= nasm_quote(p
, strlen(p
));
3467 macro_start
->type
= TOK_STRING
;
3472 * We now have a macro name, an implicit parameter count of
3473 * zero, and a string token to use as an expansion. Create
3474 * and store an SMacro.
3476 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3478 free_tlist(origline
);
3479 return DIRECTIVE_FOUND
;
3483 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3486 tline
= tline
->next
;
3488 tline
= expand_id(tline
);
3489 if (!tline
|| (tline
->type
!= TOK_ID
&&
3490 (tline
->type
!= TOK_PREPROC_ID
||
3491 tline
->text
[1] != '$'))) {
3493 "`%%strlen' expects a macro identifier as first parameter");
3494 free_tlist(origline
);
3495 return DIRECTIVE_FOUND
;
3497 ctx
= get_ctx(tline
->text
, &mname
, false);
3499 tline
= expand_smacro(tline
->next
);
3503 while (tok_type_(t
, TOK_WHITESPACE
))
3505 /* t should now point to the string */
3506 if (!tok_type_(t
, TOK_STRING
)) {
3508 "`%%strlen` requires string as second parameter");
3510 free_tlist(origline
);
3511 return DIRECTIVE_FOUND
;
3514 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3515 make_tok_num(macro_start
, nasm_unquote(t
->text
, NULL
));
3518 * We now have a macro name, an implicit parameter count of
3519 * zero, and a numeric token to use as an expansion. Create
3520 * and store an SMacro.
3522 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3524 free_tlist(origline
);
3525 return DIRECTIVE_FOUND
;
3528 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3531 tline
= tline
->next
;
3533 tline
= expand_id(tline
);
3534 if (!tline
|| (tline
->type
!= TOK_ID
&&
3535 (tline
->type
!= TOK_PREPROC_ID
||
3536 tline
->text
[1] != '$'))) {
3538 "`%%strcat' expects a macro identifier as first parameter");
3539 free_tlist(origline
);
3540 return DIRECTIVE_FOUND
;
3542 ctx
= get_ctx(tline
->text
, &mname
, false);
3544 tline
= expand_smacro(tline
->next
);
3548 list_for_each(t
, tline
) {
3550 case TOK_WHITESPACE
:
3553 len
+= t
->a
.len
= nasm_unquote(t
->text
, NULL
);
3556 if (!strcmp(t
->text
, ",")) /* permit comma separators */
3558 /* else fall through */
3561 "non-string passed to `%%strcat' (%d)", t
->type
);
3563 free_tlist(origline
);
3564 return DIRECTIVE_FOUND
;
3568 p
= pp
= nasm_malloc(len
);
3569 list_for_each(t
, tline
) {
3570 if (t
->type
== TOK_STRING
) {
3571 memcpy(p
, t
->text
, t
->a
.len
);
3577 * We now have a macro name, an implicit parameter count of
3578 * zero, and a numeric token to use as an expansion. Create
3579 * and store an SMacro.
3581 macro_start
= new_Token(NULL
, TOK_STRING
, NULL
, 0);
3582 macro_start
->text
= nasm_quote(pp
, len
);
3584 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3586 free_tlist(origline
);
3587 return DIRECTIVE_FOUND
;
3590 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3592 int64_t start
, count
;
3597 tline
= tline
->next
;
3599 tline
= expand_id(tline
);
3600 if (!tline
|| (tline
->type
!= TOK_ID
&&
3601 (tline
->type
!= TOK_PREPROC_ID
||
3602 tline
->text
[1] != '$'))) {
3604 "`%%substr' expects a macro identifier as first parameter");
3605 free_tlist(origline
);
3606 return DIRECTIVE_FOUND
;
3608 ctx
= get_ctx(tline
->text
, &mname
, false);
3610 tline
= expand_smacro(tline
->next
);
3613 if (tline
) /* skip expanded id */
3615 while (tok_type_(t
, TOK_WHITESPACE
))
3618 /* t should now point to the string */
3619 if (!tok_type_(t
, TOK_STRING
)) {
3621 "`%%substr` requires string as second parameter");
3623 free_tlist(origline
);
3624 return DIRECTIVE_FOUND
;
3629 tokval
.t_type
= TOKEN_INVALID
;
3630 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3634 free_tlist(origline
);
3635 return DIRECTIVE_FOUND
;
3636 } else if (!is_simple(evalresult
)) {
3637 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3639 free_tlist(origline
);
3640 return DIRECTIVE_FOUND
;
3642 start
= evalresult
->value
- 1;
3644 while (tok_type_(tt
, TOK_WHITESPACE
))
3647 count
= 1; /* Backwards compatibility: one character */
3649 tokval
.t_type
= TOKEN_INVALID
;
3650 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3654 free_tlist(origline
);
3655 return DIRECTIVE_FOUND
;
3656 } else if (!is_simple(evalresult
)) {
3657 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3659 free_tlist(origline
);
3660 return DIRECTIVE_FOUND
;
3662 count
= evalresult
->value
;
3665 len
= nasm_unquote(t
->text
, NULL
);
3666 /* make start and count being in range */
3670 count
= len
+ count
+ 1 - start
;
3671 if (start
+ count
> (int64_t)len
)
3672 count
= len
- start
;
3673 if (!len
|| count
< 0 || start
>=(int64_t)len
)
3674 start
= -1, count
= 0; /* empty string */
3676 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3677 macro_start
->text
= nasm_quote((start
< 0) ? "" : t
->text
+ start
, count
);
3678 macro_start
->type
= TOK_STRING
;
3681 * We now have a macro name, an implicit parameter count of
3682 * zero, and a numeric token to use as an expansion. Create
3683 * and store an SMacro.
3685 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3687 free_tlist(origline
);
3688 return DIRECTIVE_FOUND
;
3693 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3694 casesense
= (i
== PP_ASSIGN
);
3696 tline
= tline
->next
;
3698 tline
= expand_id(tline
);
3699 if (!tline
|| (tline
->type
!= TOK_ID
&&
3700 (tline
->type
!= TOK_PREPROC_ID
||
3701 tline
->text
[1] != '$'))) {
3703 "`%%%sassign' expects a macro identifier",
3704 (i
== PP_IASSIGN
? "i" : ""));
3705 free_tlist(origline
);
3706 return DIRECTIVE_FOUND
;
3708 ctx
= get_ctx(tline
->text
, &mname
, false);
3710 tline
= expand_smacro(tline
->next
);
3715 tokval
.t_type
= TOKEN_INVALID
;
3717 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3720 free_tlist(origline
);
3721 return DIRECTIVE_FOUND
;
3725 error(ERR_WARNING
|ERR_PASS1
,
3726 "trailing garbage after expression ignored");
3728 if (!is_simple(evalresult
)) {
3730 "non-constant value given to `%%%sassign'",
3731 (i
== PP_IASSIGN
? "i" : ""));
3732 free_tlist(origline
);
3733 return DIRECTIVE_FOUND
;
3736 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3737 make_tok_num(macro_start
, reloc_value(evalresult
));
3740 * We now have a macro name, an implicit parameter count of
3741 * zero, and a numeric token to use as an expansion. Create
3742 * and store an SMacro.
3744 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3745 free_tlist(origline
);
3746 return DIRECTIVE_FOUND
;
3749 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3751 * Syntax is `%line nnn[+mmm] [filename]'
3753 tline
= tline
->next
;
3755 if (!tok_type_(tline
, TOK_NUMBER
)) {
3756 error(ERR_NONFATAL
, "`%%line' expects line number");
3757 free_tlist(origline
);
3758 return DIRECTIVE_FOUND
;
3760 k
= readnum(tline
->text
, &err
);
3762 tline
= tline
->next
;
3763 if (tok_is_(tline
, "+")) {
3764 tline
= tline
->next
;
3765 if (!tok_type_(tline
, TOK_NUMBER
)) {
3766 error(ERR_NONFATAL
, "`%%line' expects line increment");
3767 free_tlist(origline
);
3768 return DIRECTIVE_FOUND
;
3770 m
= readnum(tline
->text
, &err
);
3771 tline
= tline
->next
;
3777 nasm_free(src_set_fname(detoken(tline
, false)));
3779 free_tlist(origline
);
3780 return DIRECTIVE_FOUND
;
3783 if (defining
!= NULL
) {
3784 if (defining
->type
== EXP_WHILE
) {
3785 defining
->def_depth
++;
3787 return NO_DIRECTIVE_FOUND
;
3790 if ((istk
->expansion
!= NULL
) &&
3791 (istk
->expansion
->emitting
== false)) {
3795 l
->first
= copy_Token(tline
->next
);
3796 j
= if_condition(tline
->next
, i
);
3797 tline
->next
= NULL
; /* it got freed */
3798 j
= (((j
< 0) ? COND_NEVER
: j
) ? COND_IF_TRUE
: COND_IF_FALSE
);
3800 ed
= new_ExpDef(EXP_WHILE
);
3803 ed
->max_depth
= DEADMAN_LIMIT
;
3804 ed
->ignoring
= ((ed
->state
== COND_IF_TRUE
) ? false : true);
3805 if (ed
->ignoring
== false) {
3808 } else if (l
!= NULL
) {
3809 delete_Token(l
->first
);
3813 ed
->prev
= defining
;
3815 free_tlist(origline
);
3816 return DIRECTIVE_FOUND
;
3819 if (defining
!= NULL
) {
3820 if (defining
->type
== EXP_WHILE
) {
3821 if (defining
->def_depth
> 0) {
3822 defining
->def_depth
--;
3823 return NO_DIRECTIVE_FOUND
;
3826 return NO_DIRECTIVE_FOUND
;
3829 if (tline
->next
!= NULL
) {
3830 error_precond(ERR_WARNING
|ERR_PASS1
,
3831 "trailing garbage after `%%endwhile' ignored");
3833 if ((defining
== NULL
) || (defining
->type
!= EXP_WHILE
)) {
3834 error(ERR_NONFATAL
, "`%%endwhile': no matching `%%while'");
3835 return DIRECTIVE_FOUND
;
3838 defining
= ed
->prev
;
3839 if (ed
->ignoring
== false) {
3840 ed
->prev
= expansions
;
3842 ei
= new_ExpInv(EXP_WHILE
, ed
);
3843 ei
->current
= ed
->line
->next
;
3844 ei
->emitting
= true;
3845 ei
->prev
= istk
->expansion
;
3846 istk
->expansion
= ei
;
3850 free_tlist(origline
);
3851 return DIRECTIVE_FOUND
;
3854 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3856 * We must search along istk->expansion until we hit a
3857 * while invocation. Then we disable the emitting state(s)
3858 * between exitwhile and endwhile.
3860 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
3861 if (ei
->type
== EXP_WHILE
) {
3868 * Set all invocations leading back to the while
3869 * invocation to a non-emitting state.
3871 for (eei
= istk
->expansion
; eei
!= ei
; eei
= eei
->prev
) {
3872 eei
->emitting
= false;
3874 eei
->emitting
= false;
3875 eei
->current
= NULL
;
3876 eei
->def
->cur_depth
= eei
->def
->max_depth
;
3878 error(ERR_NONFATAL
, "`%%exitwhile' not within `%%while' block");
3880 free_tlist(origline
);
3881 return DIRECTIVE_FOUND
;
3884 if (defining
!= NULL
) {
3885 if (defining
->type
== EXP_COMMENT
) {
3886 defining
->def_depth
++;
3888 return NO_DIRECTIVE_FOUND
;
3890 ed
= new_ExpDef(EXP_COMMENT
);
3891 ed
->ignoring
= true;
3892 ed
->prev
= defining
;
3894 free_tlist(origline
);
3895 return DIRECTIVE_FOUND
;
3898 if (defining
!= NULL
) {
3899 if (defining
->type
== EXP_COMMENT
) {
3900 if (defining
->def_depth
> 0) {
3901 defining
->def_depth
--;
3902 return NO_DIRECTIVE_FOUND
;
3905 return NO_DIRECTIVE_FOUND
;
3908 if ((defining
== NULL
) || (defining
->type
!= EXP_COMMENT
)) {
3909 error(ERR_NONFATAL
, "`%%endcomment': no matching `%%comment'");
3910 return DIRECTIVE_FOUND
;
3913 defining
= ed
->prev
;
3915 free_tlist(origline
);
3916 return DIRECTIVE_FOUND
;
3919 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3920 if (in_final
!= false) {
3921 error(ERR_FATAL
, "`%%final' cannot be used recursively");
3923 tline
= tline
->next
;
3925 if (tline
== NULL
) {
3926 error(ERR_NONFATAL
, "`%%final' expects at least one parameter");
3929 l
->first
= copy_Token(tline
);
3933 free_tlist(origline
);
3934 return DIRECTIVE_FOUND
;
3937 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3938 tline
= tline
->next
;
3940 if (tline
== NULL
) {
3941 error(ERR_NONFATAL
, "`%%pragma' expects at least one parameter");
3945 free_tlist(origline
);
3946 return DIRECTIVE_FOUND
;
3950 "preprocessor directive `%s' not yet implemented",
3952 return DIRECTIVE_FOUND
;
3957 * Ensure that a macro parameter contains a condition code and
3958 * nothing else. Return the condition code index if so, or -1
3961 static int find_cc(Token
* t
)
3967 return -1; /* Probably a %+ without a space */
3970 if (t
->type
!= TOK_ID
)
3974 if (tt
&& (tt
->type
!= TOK_OTHER
|| strcmp(tt
->text
, ",")))
3978 j
= ARRAY_SIZE(conditions
);
3981 m
= nasm_stricmp(t
->text
, conditions
[k
]);
3996 static bool paste_tokens(Token
**head
, const struct tokseq_match
*m
,
3997 int mnum
, bool handle_paste_tokens
)
3999 Token
**tail
, *t
, *tt
;
4001 bool did_paste
= false;
4005 /* Now handle token pasting... */
4008 while ((t
= *tail
) && (tt
= t
->next
)) {
4010 case TOK_WHITESPACE
:
4011 if (tt
->type
== TOK_WHITESPACE
) {
4012 /* Zap adjacent whitespace tokens */
4013 t
->next
= delete_Token(tt
);
4015 /* Do not advance paste_head here */
4019 case TOK_PASTE
: /* %+ */
4020 if (handle_paste_tokens
) {
4021 /* Zap %+ and whitespace tokens to the right */
4022 while (t
&& (t
->type
== TOK_WHITESPACE
||
4023 t
->type
== TOK_PASTE
))
4024 t
= *tail
= delete_Token(t
);
4025 if (!paste_head
|| !t
)
4026 break; /* Nothing to paste with */
4030 while (tok_type_(tt
, TOK_WHITESPACE
))
4031 tt
= t
->next
= delete_Token(tt
);
4033 tmp
= nasm_strcat(t
->text
, tt
->text
);
4035 tt
= delete_Token(tt
);
4036 t
= *tail
= tokenize(tmp
);
4042 t
->next
= tt
; /* Attach the remaining token chain */
4049 /* else fall through */
4052 * Concatenation of tokens might look nontrivial
4053 * but in real it's pretty simple -- the caller
4054 * prepares the masks of token types to be concatenated
4055 * and we simply find matched sequences and slip
4058 for (i
= 0; i
< mnum
; i
++) {
4059 if (PP_CONCAT_MASK(t
->type
) & m
[i
].mask_head
) {
4063 while (tt
&& (PP_CONCAT_MASK(tt
->type
) & m
[i
].mask_tail
)) {
4064 len
+= strlen(tt
->text
);
4069 * Now tt points to the first token after
4070 * the potential paste area...
4072 if (tt
!= t
->next
) {
4073 /* We have at least two tokens... */
4074 len
+= strlen(t
->text
);
4075 p
= tmp
= nasm_malloc(len
+1);
4078 p
= strchr(p
, '\0');
4079 t
= delete_Token(t
);
4081 t
= *tail
= tokenize(tmp
);
4087 t
->next
= tt
; /* Attach the remaining token chain */
4095 if (i
>= mnum
) { /* no match */
4097 if (!tok_type_(t
->next
, TOK_WHITESPACE
))
4107 * expands to a list of tokens from %{x:y}
4109 static Token
*expand_mmac_params_range(ExpInv
*ei
, Token
*tline
, Token
***last
)
4111 Token
*t
= tline
, **tt
, *tm
, *head
;
4115 pos
= strchr(tline
->text
, ':');
4118 lst
= atoi(pos
+ 1);
4119 fst
= atoi(tline
->text
+ 1);
4122 * only macros params are accounted so
4123 * if someone passes %0 -- we reject such
4126 if (lst
== 0 || fst
== 0)
4129 /* the values should be sane */
4130 if ((fst
> (int)ei
->nparam
|| fst
< (-(int)ei
->nparam
)) ||
4131 (lst
> (int)ei
->nparam
|| lst
< (-(int)ei
->nparam
)))
4134 fst
= fst
< 0 ? fst
+ (int)ei
->nparam
+ 1: fst
;
4135 lst
= lst
< 0 ? lst
+ (int)ei
->nparam
+ 1: lst
;
4137 /* counted from zero */
4141 * it will be at least one token
4143 tm
= ei
->params
[(fst
+ ei
->rotate
) % ei
->nparam
];
4144 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
4145 head
= t
, tt
= &t
->next
;
4147 for (i
= fst
+ 1; i
<= lst
; i
++) {
4148 t
= new_Token(NULL
, TOK_OTHER
, ",", 0);
4149 *tt
= t
, tt
= &t
->next
;
4150 j
= (i
+ ei
->rotate
) % ei
->nparam
;
4152 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
4153 *tt
= t
, tt
= &t
->next
;
4156 for (i
= fst
- 1; i
>= lst
; i
--) {
4157 t
= new_Token(NULL
, TOK_OTHER
, ",", 0);
4158 *tt
= t
, tt
= &t
->next
;
4159 j
= (i
+ ei
->rotate
) % ei
->nparam
;
4161 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
4162 *tt
= t
, tt
= &t
->next
;
4170 error(ERR_NONFATAL
, "`%%{%s}': macro parameters out of range",
4176 * Expand MMacro-local things: parameter references (%0, %n, %+n,
4177 * %-n) and MMacro-local identifiers (%%foo) as well as
4178 * macro indirection (%[...]) and range (%{..:..}).
4180 static Token
*expand_mmac_params(Token
* tline
)
4182 Token
*t
, *tt
, **tail
, *thead
;
4183 bool changed
= false;
4190 if (tline
->type
== TOK_PREPROC_ID
&&
4191 (((tline
->text
[1] == '+' || tline
->text
[1] == '-') && tline
->text
[2]) ||
4192 (tline
->text
[1] >= '0' && tline
->text
[1] <= '9') ||
4193 tline
->text
[1] == '%')) {
4195 int type
= 0, cc
; /* type = 0 to placate optimisers */
4202 tline
= tline
->next
;
4204 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
4205 if (ei
->type
== EXP_MMACRO
) {
4210 error(ERR_NONFATAL
, "`%s': not in a macro call", t
->text
);
4212 pos
= strchr(t
->text
, ':');
4214 switch (t
->text
[1]) {
4216 * We have to make a substitution of one of the
4217 * forms %1, %-1, %+1, %%foo, %0.
4220 if ((strlen(t
->text
) > 2) && (t
->text
[2] == '0')) {
4222 text
= nasm_strdup(ei
->label_text
);
4225 snprintf(tmpbuf
, sizeof(tmpbuf
), "%d", ei
->nparam
);
4226 text
= nasm_strdup(tmpbuf
);
4231 snprintf(tmpbuf
, sizeof(tmpbuf
), "..@%"PRIu64
".",
4233 text
= nasm_strcat(tmpbuf
, t
->text
+ 2);
4236 n
= atoi(t
->text
+ 2) - 1;
4237 if (n
>= ei
->nparam
)
4241 n
= (n
+ ei
->rotate
) % ei
->nparam
;
4247 "macro parameter %d is not a condition code",
4252 if (inverse_ccs
[cc
] == -1) {
4254 "condition code `%s' is not invertible",
4258 text
= nasm_strdup(conditions
[inverse_ccs
[cc
]]);
4262 n
= atoi(t
->text
+ 2) - 1;
4263 if (n
>= ei
->nparam
)
4267 n
= (n
+ ei
->rotate
) % ei
->nparam
;
4273 "macro parameter %d is not a condition code",
4278 text
= nasm_strdup(conditions
[cc
]);
4282 n
= atoi(t
->text
+ 1) - 1;
4283 if (n
>= ei
->nparam
)
4287 n
= (n
+ ei
->rotate
) % ei
->nparam
;
4291 for (i
= 0; i
< ei
->paramlen
[n
]; i
++) {
4292 *tail
= new_Token(NULL
, tt
->type
, tt
->text
, 0);
4293 tail
= &(*tail
)->next
;
4297 text
= NULL
; /* we've done it here */
4302 * seems we have a parameters range here
4304 Token
*head
, **last
;
4305 head
= expand_mmac_params_range(ei
, t
, &last
);
4326 } else if (tline
->type
== TOK_INDIRECT
) {
4328 tline
= tline
->next
;
4329 tt
= tokenize(t
->text
);
4330 tt
= expand_mmac_params(tt
);
4331 tt
= expand_smacro(tt
);
4334 tt
->a
.mac
= NULL
; /* Necessary? */
4342 tline
= tline
->next
;
4350 const struct tokseq_match t
[] = {
4352 PP_CONCAT_MASK(TOK_ID
) |
4353 PP_CONCAT_MASK(TOK_FLOAT
), /* head */
4354 PP_CONCAT_MASK(TOK_ID
) |
4355 PP_CONCAT_MASK(TOK_NUMBER
) |
4356 PP_CONCAT_MASK(TOK_FLOAT
) |
4357 PP_CONCAT_MASK(TOK_OTHER
) /* tail */
4360 PP_CONCAT_MASK(TOK_NUMBER
), /* head */
4361 PP_CONCAT_MASK(TOK_NUMBER
) /* tail */
4364 paste_tokens(&thead
, t
, ARRAY_SIZE(t
), false);
4371 * Expand all single-line macro calls made in the given line.
4372 * Return the expanded version of the line. The original is deemed
4373 * to be destroyed in the process. (In reality we'll just move
4374 * Tokens from input to output a lot of the time, rather than
4375 * actually bothering to destroy and replicate.)
4378 static Token
*expand_smacro(Token
* tline
)
4380 Token
*t
, *tt
, *mstart
, **tail
, *thead
;
4381 SMacro
*head
= NULL
, *m
;
4384 unsigned int nparam
, sparam
;
4386 Token
*org_tline
= tline
;
4389 int deadman
= DEADMAN_LIMIT
;
4393 * Trick: we should avoid changing the start token pointer since it can
4394 * be contained in "next" field of other token. Because of this
4395 * we allocate a copy of first token and work with it; at the end of
4396 * routine we copy it back
4399 tline
= new_Token(org_tline
->next
, org_tline
->type
,
4400 org_tline
->text
, 0);
4401 tline
->a
.mac
= org_tline
->a
.mac
;
4402 nasm_free(org_tline
->text
);
4403 org_tline
->text
= NULL
;
4406 expanded
= true; /* Always expand %+ at least once */
4412 while (tline
) { /* main token loop */
4414 error(ERR_NONFATAL
, "interminable macro recursion");
4418 if ((mname
= tline
->text
)) {
4419 /* if this token is a local macro, look in local context */
4420 if (tline
->type
== TOK_ID
) {
4421 head
= (SMacro
*)hash_findix(&smacros
, mname
);
4422 } else if (tline
->type
== TOK_PREPROC_ID
) {
4423 ctx
= get_ctx(mname
, &mname
, false);
4424 head
= ctx
? (SMacro
*)hash_findix(&ctx
->localmac
, mname
) : NULL
;
4429 * We've hit an identifier. As in is_mmacro below, we first
4430 * check whether the identifier is a single-line macro at
4431 * all, then think about checking for parameters if
4434 list_for_each(m
, head
)
4435 if (!mstrcmp(m
->name
, mname
, m
->casesense
))
4441 if (m
->nparam
== 0) {
4443 * Simple case: the macro is parameterless. Discard the
4444 * one token that the macro call took, and push the
4445 * expansion back on the to-do stack.
4447 if (!m
->expansion
) {
4448 if (!strcmp("__FILE__", m
->name
)) {
4451 src_get(&num
, &file
);
4452 tline
->text
= nasm_quote(file
, strlen(file
));
4453 tline
->type
= TOK_STRING
;
4457 if (!strcmp("__LINE__", m
->name
)) {
4458 nasm_free(tline
->text
);
4459 make_tok_num(tline
, src_get_linnum());
4462 if (!strcmp("__BITS__", m
->name
)) {
4463 nasm_free(tline
->text
);
4464 make_tok_num(tline
, globalbits
);
4467 tline
= delete_Token(tline
);
4472 * Complicated case: at least one macro with this name
4473 * exists and takes parameters. We must find the
4474 * parameters in the call, count them, find the SMacro
4475 * that corresponds to that form of the macro call, and
4476 * substitute for the parameters when we expand. What a
4479 /*tline = tline->next;
4480 skip_white_(tline); */
4483 while (tok_type_(t
, TOK_SMAC_END
)) {
4484 t
->a
.mac
->in_progress
= false;
4486 t
= tline
->next
= delete_Token(t
);
4489 } while (tok_type_(tline
, TOK_WHITESPACE
));
4490 if (!tok_is_(tline
, "(")) {
4492 * This macro wasn't called with parameters: ignore
4493 * the call. (Behaviour borrowed from gnu cpp.)
4502 sparam
= PARAM_DELTA
;
4503 params
= nasm_malloc(sparam
* sizeof(Token
*));
4504 params
[0] = tline
->next
;
4505 paramsize
= nasm_malloc(sparam
* sizeof(int));
4507 while (true) { /* parameter loop */
4509 * For some unusual expansions
4510 * which concatenates function call
4513 while (tok_type_(t
, TOK_SMAC_END
)) {
4514 t
->a
.mac
->in_progress
= false;
4516 t
= tline
->next
= delete_Token(t
);
4522 "macro call expects terminating `)'");
4525 if (tline
->type
== TOK_WHITESPACE
4527 if (paramsize
[nparam
])
4530 params
[nparam
] = tline
->next
;
4531 continue; /* parameter loop */
4533 if (tline
->type
== TOK_OTHER
4534 && tline
->text
[1] == 0) {
4535 char ch
= tline
->text
[0];
4536 if (ch
== ',' && !paren
&& brackets
<= 0) {
4537 if (++nparam
>= sparam
) {
4538 sparam
+= PARAM_DELTA
;
4539 params
= nasm_realloc(params
,
4540 sparam
* sizeof(Token
*));
4541 paramsize
= nasm_realloc(paramsize
,
4542 sparam
* sizeof(int));
4544 params
[nparam
] = tline
->next
;
4545 paramsize
[nparam
] = 0;
4547 continue; /* parameter loop */
4550 (brackets
> 0 || (brackets
== 0 &&
4551 !paramsize
[nparam
])))
4553 if (!(brackets
++)) {
4554 params
[nparam
] = tline
->next
;
4555 continue; /* parameter loop */
4558 if (ch
== '}' && brackets
> 0)
4559 if (--brackets
== 0) {
4561 continue; /* parameter loop */
4563 if (ch
== '(' && !brackets
)
4565 if (ch
== ')' && brackets
<= 0)
4571 error(ERR_NONFATAL
, "braces do not "
4572 "enclose all of macro parameter");
4574 paramsize
[nparam
] += white
+ 1;
4576 } /* parameter loop */
4578 while (m
&& (m
->nparam
!= nparam
||
4579 mstrcmp(m
->name
, mname
,
4583 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MNP
,
4584 "macro `%s' exists, "
4585 "but not taking %d parameters",
4586 mstart
->text
, nparam
);
4589 if (m
&& m
->in_progress
)
4591 if (!m
) { /* in progess or didn't find '(' or wrong nparam */
4593 * Design question: should we handle !tline, which
4594 * indicates missing ')' here, or expand those
4595 * macros anyway, which requires the (t) test a few
4599 nasm_free(paramsize
);
4603 * Expand the macro: we are placed on the last token of the
4604 * call, so that we can easily split the call from the
4605 * following tokens. We also start by pushing an SMAC_END
4606 * token for the cycle removal.
4613 tt
= new_Token(tline
, TOK_SMAC_END
, NULL
, 0);
4615 m
->in_progress
= true;
4617 list_for_each(t
, m
->expansion
) {
4618 if (t
->type
>= TOK_SMAC_PARAM
) {
4619 Token
*pcopy
= tline
, **ptail
= &pcopy
;
4623 ttt
= params
[t
->type
- TOK_SMAC_PARAM
];
4624 i
= paramsize
[t
->type
- TOK_SMAC_PARAM
];
4626 pt
= *ptail
= new_Token(tline
, ttt
->type
,
4632 } else if (t
->type
== TOK_PREPROC_Q
) {
4633 tt
= new_Token(tline
, TOK_ID
, mname
, 0);
4635 } else if (t
->type
== TOK_PREPROC_QQ
) {
4636 tt
= new_Token(tline
, TOK_ID
, m
->name
, 0);
4639 tt
= new_Token(tline
, t
->type
, t
->text
, 0);
4645 * Having done that, get rid of the macro call, and clean
4646 * up the parameters.
4649 nasm_free(paramsize
);
4652 continue; /* main token loop */
4657 if (tline
->type
== TOK_SMAC_END
) {
4658 tline
->a
.mac
->in_progress
= false;
4659 tline
= delete_Token(tline
);
4662 tline
= tline
->next
;
4670 * Now scan the entire line and look for successive TOK_IDs that resulted
4671 * after expansion (they can't be produced by tokenize()). The successive
4672 * TOK_IDs should be concatenated.
4673 * Also we look for %+ tokens and concatenate the tokens before and after
4674 * them (without white spaces in between).
4677 const struct tokseq_match t
[] = {
4679 PP_CONCAT_MASK(TOK_ID
) |
4680 PP_CONCAT_MASK(TOK_PREPROC_ID
), /* head */
4681 PP_CONCAT_MASK(TOK_ID
) |
4682 PP_CONCAT_MASK(TOK_PREPROC_ID
) |
4683 PP_CONCAT_MASK(TOK_NUMBER
) /* tail */
4686 if (paste_tokens(&thead
, t
, ARRAY_SIZE(t
), true)) {
4688 * If we concatenated something, *and* we had previously expanded
4689 * an actual macro, scan the lines again for macros...
4700 *org_tline
= *thead
;
4701 /* since we just gave text to org_line, don't free it */
4703 delete_Token(thead
);
4705 /* the expression expanded to empty line;
4706 we can't return NULL for some reasons
4707 we just set the line to a single WHITESPACE token. */
4708 memset(org_tline
, 0, sizeof(*org_tline
));
4709 org_tline
->text
= NULL
;
4710 org_tline
->type
= TOK_WHITESPACE
;
4719 * Similar to expand_smacro but used exclusively with macro identifiers
4720 * right before they are fetched in. The reason is that there can be
4721 * identifiers consisting of several subparts. We consider that if there
4722 * are more than one element forming the name, user wants a expansion,
4723 * otherwise it will be left as-is. Example:
4727 * the identifier %$abc will be left as-is so that the handler for %define
4728 * will suck it and define the corresponding value. Other case:
4730 * %define _%$abc cde
4732 * In this case user wants name to be expanded *before* %define starts
4733 * working, so we'll expand %$abc into something (if it has a value;
4734 * otherwise it will be left as-is) then concatenate all successive
4737 static Token
*expand_id(Token
* tline
)
4739 Token
*cur
, *oldnext
= NULL
;
4741 if (!tline
|| !tline
->next
)
4746 (cur
->next
->type
== TOK_ID
||
4747 cur
->next
->type
== TOK_PREPROC_ID
4748 || cur
->next
->type
== TOK_NUMBER
))
4751 /* If identifier consists of just one token, don't expand */
4756 oldnext
= cur
->next
; /* Detach the tail past identifier */
4757 cur
->next
= NULL
; /* so that expand_smacro stops here */
4760 tline
= expand_smacro(tline
);
4763 /* expand_smacro possibly changhed tline; re-scan for EOL */
4765 while (cur
&& cur
->next
)
4768 cur
->next
= oldnext
;
4775 * Determine whether the given line constitutes a multi-line macro
4776 * call, and return the ExpDef structure called if so. Doesn't have
4777 * to check for an initial label - that's taken care of in
4778 * expand_mmacro - but must check numbers of parameters. Guaranteed
4779 * to be called with tline->type == TOK_ID, so the putative macro
4780 * name is easy to find.
4782 static ExpDef
*is_mmacro(Token
* tline
, Token
*** params_array
)
4788 head
= (ExpDef
*) hash_findix(&expdefs
, tline
->text
);
4791 * Efficiency: first we see if any macro exists with the given
4792 * name. If not, we can return NULL immediately. _Then_ we
4793 * count the parameters, and then we look further along the
4794 * list if necessary to find the proper ExpDef.
4796 list_for_each(ed
, head
)
4797 if (!mstrcmp(ed
->name
, tline
->text
, ed
->casesense
))
4803 * OK, we have a potential macro. Count and demarcate the
4806 count_mmac_params(tline
->next
, &nparam
, ¶ms
);
4809 * So we know how many parameters we've got. Find the ExpDef
4810 * structure that handles this number.
4813 if (ed
->nparam_min
<= nparam
4814 && (ed
->plus
|| nparam
<= ed
->nparam_max
)) {
4816 * It's right, and we can use it. Add its default
4817 * parameters to the end of our list if necessary.
4819 if (ed
->defaults
&& nparam
< ed
->nparam_min
+ ed
->ndefs
) {
4821 nasm_realloc(params
,
4822 ((ed
->nparam_min
+ ed
->ndefs
+
4823 1) * sizeof(*params
)));
4824 while (nparam
< ed
->nparam_min
+ ed
->ndefs
) {
4825 params
[nparam
] = ed
->defaults
[nparam
- ed
->nparam_min
];
4830 * If we've gone over the maximum parameter count (and
4831 * we're in Plus mode), ignore parameters beyond
4834 if (ed
->plus
&& nparam
> ed
->nparam_max
)
4835 nparam
= ed
->nparam_max
;
4837 * Then terminate the parameter list, and leave.
4839 if (!params
) { /* need this special case */
4840 params
= nasm_malloc(sizeof(*params
));
4843 params
[nparam
] = NULL
;
4844 *params_array
= params
;
4848 * This one wasn't right: look for the next one with the
4851 list_for_each(ed
, ed
->next
)
4852 if (!mstrcmp(ed
->name
, tline
->text
, ed
->casesense
))
4857 * After all that, we didn't find one with the right number of
4858 * parameters. Issue a warning, and fail to expand the macro.
4860 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MNP
,
4861 "macro `%s' exists, but not taking %d parameters",
4862 tline
->text
, nparam
);
4868 * Expand the multi-line macro call made by the given line, if
4869 * there is one to be expanded. If there is, push the expansion on
4870 * istk->expansion and return true. Otherwise return false.
4872 static bool expand_mmacro(Token
* tline
)
4874 Token
*label
= NULL
;
4875 int dont_prepend
= 0;
4876 Token
**params
, *t
, *mtok
;
4880 int i
, nparam
, *paramlen
;
4885 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
4886 if (!tok_type_(t
, TOK_ID
) && !tok_type_(t
, TOK_PREPROC_ID
))
4889 ed
= is_mmacro(t
, ¶ms
);
4895 * We have an id which isn't a macro call. We'll assume
4896 * it might be a label; we'll also check to see if a
4897 * colon follows it. Then, if there's another id after
4898 * that lot, we'll check it again for macro-hood.
4902 if (tok_type_(t
, TOK_WHITESPACE
))
4903 last
= t
, t
= t
->next
;
4904 if (tok_is_(t
, ":")) {
4906 last
= t
, t
= t
->next
;
4907 if (tok_type_(t
, TOK_WHITESPACE
))
4908 last
= t
, t
= t
->next
;
4910 if (!tok_type_(t
, TOK_ID
) || !(ed
= is_mmacro(t
, ¶ms
)))
4918 * Fix up the parameters: this involves stripping leading and
4919 * trailing whitespace, then stripping braces if they are
4922 for (nparam
= 0; params
[nparam
]; nparam
++) ;
4923 paramlen
= nparam
? nasm_malloc(nparam
* sizeof(*paramlen
)) : NULL
;
4925 for (i
= 0; params
[i
]; i
++) {
4927 int comma
= (!ed
->plus
|| i
< nparam
- 1);
4931 if (tok_is_(t
, "{"))
4932 t
= t
->next
, brace
= true, comma
= false;
4936 if (comma
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, ","))
4937 break; /* ... because we have hit a comma */
4938 if (comma
&& t
->type
== TOK_WHITESPACE
4939 && tok_is_(t
->next
, ","))
4940 break; /* ... or a space then a comma */
4941 if (brace
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, "}"))
4942 break; /* ... or a brace */
4948 if (ed
->cur_depth
>= ed
->max_depth
) {
4949 if (ed
->max_depth
> 1) {
4951 "reached maximum macro recursion depth of %i for %s",
4952 ed
->max_depth
,ed
->name
);
4960 * OK, we have found a ExpDef structure representing a
4961 * previously defined mmacro. Create an expansion invocation
4962 * and point it back to the expansion definition. Substitution of
4963 * parameter tokens and macro-local tokens doesn't get done
4964 * until the single-line macro substitution process; this is
4965 * because delaying them allows us to change the semantics
4966 * later through %rotate.
4968 ei
= new_ExpInv(EXP_MMACRO
, ed
);
4969 ei
->name
= nasm_strdup(mname
);
4970 //ei->label = label;
4971 //ei->label_text = detoken(label, false);
4972 ei
->current
= ed
->line
;
4973 ei
->emitting
= true;
4974 //ei->iline = tline;
4975 ei
->params
= params
;
4976 ei
->nparam
= nparam
;
4978 ei
->paramlen
= paramlen
;
4981 ei
->prev
= istk
->expansion
;
4982 istk
->expansion
= ei
;
4985 * Special case: detect %00 on first invocation; if found,
4986 * avoid emitting any labels that precede the mmacro call.
4987 * ed->prepend is set to -1 when %00 is detected, else 1.
4989 if (ed
->prepend
== 0) {
4990 for (l
= ed
->line
; l
!= NULL
; l
= l
->next
) {
4991 for (t
= l
->first
; t
!= NULL
; t
= t
->next
) {
4992 if ((t
->type
== TOK_PREPROC_ID
) &&
4993 (strlen(t
->text
) == 3) &&
4994 (t
->text
[1] == '0') && (t
->text
[2] == '0')) {
4999 if (dont_prepend
< 0) {
5003 ed
->prepend
= ((dont_prepend
< 0) ? -1 : 1);
5007 * If we had a label, push it on as the first line of
5008 * the macro expansion.
5010 if (label
!= NULL
) {
5011 if (ed
->prepend
< 0) {
5012 ei
->label_text
= detoken(label
, false);
5014 if (dont_prepend
== 0) {
5016 while (t
->next
!= NULL
) {
5019 t
->next
= new_Token(NULL
, TOK_OTHER
, ":", 0);
5022 l
->first
= copy_Token(label
);
5023 l
->next
= ei
->current
;
5028 list
->uplevel(ed
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
5034 /* The function that actually does the error reporting */
5035 static void verror(int severity
, const char *fmt
, va_list arg
)
5039 vsnprintf(buff
, sizeof(buff
), fmt
, arg
);
5041 if (istk
&& istk
->mmac_depth
> 0) {
5042 ExpInv
*ei
= istk
->expansion
;
5043 int lineno
= ei
->lineno
;
5045 if (ei
->type
== EXP_MMACRO
)
5047 lineno
+= ei
->relno
;
5050 nasm_error(severity
, "(%s:%d) %s", ei
->def
->name
,
5053 nasm_error(severity
, "%s", buff
);
5057 * Since preprocessor always operate only on the line that didn't
5058 * arrived yet, we should always use ERR_OFFBY1.
5060 static void error(int severity
, const char *fmt
, ...)
5064 verror(severity
, fmt
, arg
);
5069 * Because %else etc are evaluated in the state context
5070 * of the previous branch, errors might get lost with error():
5071 * %if 0 ... %else trailing garbage ... %endif
5072 * So %else etc should report errors with this function.
5074 static void error_precond(int severity
, const char *fmt
, ...)
5078 /* Only ignore the error if it's really in a dead branch */
5079 if ((istk
!= NULL
) &&
5080 (istk
->expansion
!= NULL
) &&
5081 (istk
->expansion
->type
== EXP_IF
) &&
5082 (istk
->expansion
->def
->state
== COND_NEVER
))
5086 verror(severity
, fmt
, arg
);
5091 pp_reset(char *file
, int apass
, ListGen
* listgen
, StrList
**deplist
)
5096 istk
= nasm_zalloc(sizeof(Include
));
5097 istk
->fp
= fopen(file
, "r");
5098 src_set_fname(nasm_strdup(file
));
5102 error(ERR_FATAL
|ERR_NOFILE
, "unable to open input file `%s'",
5107 nested_mac_count
= 0;
5108 nested_rep_count
= 0;
5111 if (tasm_compatible_mode
) {
5112 stdmacpos
= nasm_stdmac
;
5114 stdmacpos
= nasm_stdmac_after_tasm
;
5116 any_extrastdmac
= extrastdmac
&& *extrastdmac
;
5121 * 0 for dependencies, 1 for preparatory passes, 2 for final pass.
5122 * The caller, however, will also pass in 3 for preprocess-only so
5123 * we can set __PASS__ accordingly.
5125 pass
= apass
> 2 ? 2 : apass
;
5127 dephead
= deptail
= deplist
;
5129 StrList
*sl
= nasm_malloc(strlen(file
)+1+sizeof sl
->next
);
5131 strcpy(sl
->str
, file
);
5133 deptail
= &sl
->next
;
5137 * Define the __PASS__ macro. This is defined here unlike
5138 * all the other builtins, because it is special -- it varies between
5141 t
= nasm_zalloc(sizeof(*t
));
5142 make_tok_num(t
, apass
);
5143 define_smacro(NULL
, "__PASS__", true, 0, t
);
5146 static char *pp_getline(void)
5157 * Fetch a tokenized line, either from the expansion
5158 * buffer or from the input file.
5162 while (1) { /* until we get a line we can use */
5164 * Fetch a tokenized line from the expansion buffer
5166 if (istk
->expansion
!= NULL
) {
5167 ei
= istk
->expansion
;
5168 if (ei
->current
!= NULL
) {
5169 if (ei
->emitting
== false) {
5174 ei
->current
= l
->next
;
5176 tline
= copy_Token(l
->first
);
5177 if (((ei
->type
== EXP_REP
) ||
5178 (ei
->type
== EXP_MMACRO
) ||
5179 (ei
->type
== EXP_WHILE
))
5180 && (ei
->def
->nolist
== false)) {
5181 char *p
= detoken(tline
, false);
5182 list
->line(LIST_MACRO
, p
);
5185 if (ei
->linnum
> -1) {
5186 src_set_linnum(src_get_linnum() + 1);
5189 } else if ((ei
->type
== EXP_REP
) &&
5190 (ei
->def
->cur_depth
< ei
->def
->max_depth
)) {
5191 ei
->def
->cur_depth
++;
5192 ei
->current
= ei
->def
->line
;
5195 } else if ((ei
->type
== EXP_WHILE
) &&
5196 (ei
->def
->cur_depth
< ei
->def
->max_depth
)) {
5197 ei
->current
= ei
->def
->line
;
5199 tline
= copy_Token(ei
->current
->first
);
5200 j
= if_condition(tline
, PP_WHILE
);
5202 j
= (((j
< 0) ? COND_NEVER
: j
) ? COND_IF_TRUE
: COND_IF_FALSE
);
5203 if (j
== COND_IF_TRUE
) {
5204 ei
->current
= ei
->current
->next
;
5205 ei
->def
->cur_depth
++;
5207 ei
->emitting
= false;
5209 ei
->def
->cur_depth
= ei
->def
->max_depth
;
5213 istk
->expansion
= ei
->prev
;
5216 if ((ei
->emitting
== true) &&
5217 (ed
->max_depth
== DEADMAN_LIMIT
) &&
5218 (ed
->cur_depth
== DEADMAN_LIMIT
)
5220 error(ERR_FATAL
, "runaway expansion detected, aborting");
5222 if (ed
->cur_depth
> 0) {
5224 } else if (ed
->type
!= EXP_MMACRO
) {
5225 expansions
= ed
->prev
;
5228 if ((ei
->type
== EXP_REP
) ||
5229 (ei
->type
== EXP_MMACRO
) ||
5230 (ei
->type
== EXP_WHILE
)) {
5231 list
->downlevel(LIST_MACRO
);
5232 if (ei
->type
== EXP_MMACRO
) {
5237 if (ei
->linnum
> -1) {
5238 src_set_linnum(ei
->linnum
);
5246 * Read in line from input and tokenize
5249 if (line
) { /* from the current input file */
5250 line
= prepreproc(line
);
5251 tline
= tokenize(line
);
5257 * The current file has ended; work down the istk
5262 if (i
->expansion
!= NULL
) {
5264 "end of file while still in an expansion");
5266 /* only set line and file name if there's a next node */
5268 src_set_linnum(i
->lineno
);
5269 nasm_free(src_set_fname(nasm_strdup(i
->fname
)));
5271 if ((i
->next
== NULL
) && (finals
!= NULL
)) {
5273 ei
= new_ExpInv(EXP_FINAL
, NULL
);
5274 ei
->emitting
= true;
5275 ei
->current
= finals
;
5276 istk
->expansion
= ei
;
5281 list
->downlevel(LIST_INCLUDE
);
5284 if (finals
!= NULL
) {
5294 if (defining
== NULL
) {
5295 tline
= expand_mmac_params(tline
);
5299 * Check the line to see if it's a preprocessor directive.
5301 if (do_directive(tline
) == DIRECTIVE_FOUND
) {
5303 } else if (defining
!= NULL
) {
5305 * We're defining an expansion. We emit nothing at all,
5306 * and just shove the tokenized line on to the definition.
5308 if (defining
->ignoring
== false) {
5309 Line
*l
= new_Line();
5311 if (defining
->line
== NULL
) {
5315 defining
->last
->next
= l
;
5321 defining
->linecount
++;
5323 } else if ((istk
->expansion
!= NULL
) &&
5324 (istk
->expansion
->emitting
!= true)) {
5326 * We're in a non-emitting branch of an expansion.
5327 * Emit nothing at all, not even a blank line: when we
5328 * emerge from the expansion we'll give a line-number
5329 * directive so we keep our place correctly.
5334 tline
= expand_smacro(tline
);
5335 if (expand_mmacro(tline
) != true) {
5337 * De-tokenize the line again, and emit it.
5339 line
= detoken(tline
, true);
5350 static void pp_cleanup(int pass
)
5352 if (defining
!= NULL
) {
5353 error(ERR_NONFATAL
, "end of file while still defining an expansion");
5354 while (defining
!= NULL
) {
5355 ExpDef
*ed
= defining
;
5356 defining
= ed
->prev
;
5361 while (cstk
!= NULL
)
5364 while (istk
!= NULL
) {
5368 nasm_free(i
->fname
);
5369 while (i
->expansion
!= NULL
) {
5370 ExpInv
*ei
= i
->expansion
;
5371 i
->expansion
= ei
->prev
;
5378 nasm_free(src_set_fname(NULL
));
5383 while ((i
= ipath
)) {
5392 void pp_include_path(char *path
)
5394 IncPath
*i
= nasm_zalloc(sizeof(IncPath
));
5397 i
->path
= nasm_strdup(path
);
5409 void pp_pre_include(char *fname
)
5411 Token
*inc
, *space
, *name
;
5414 name
= new_Token(NULL
, TOK_INTERNAL_STRING
, fname
, 0);
5415 space
= new_Token(name
, TOK_WHITESPACE
, NULL
, 0);
5416 inc
= new_Token(space
, TOK_PREPROC_ID
, "%include", 0);
5424 void pp_pre_define(char *definition
)
5430 equals
= strchr(definition
, '=');
5431 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
5432 def
= new_Token(space
, TOK_PREPROC_ID
, "%define", 0);
5435 space
->next
= tokenize(definition
);
5445 void pp_pre_undefine(char *definition
)
5450 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
5451 def
= new_Token(space
, TOK_PREPROC_ID
, "%undef", 0);
5452 space
->next
= tokenize(definition
);
5461 * This function is used to assist with "runtime" preprocessor
5462 * directives, e.g. pp_runtime("%define __BITS__ 64");
5464 * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
5465 * PASS A VALID STRING TO THIS FUNCTION!!!!!
5468 void pp_runtime(char *definition
)
5472 def
= tokenize(definition
);
5473 if (do_directive(def
) == NO_DIRECTIVE_FOUND
)
5478 void pp_extra_stdmac(macros_t
*macros
)
5480 extrastdmac
= macros
;
5483 static void make_tok_num(Token
* tok
, int64_t val
)
5486 snprintf(numbuf
, sizeof(numbuf
), "%"PRId64
"", val
);
5487 tok
->text
= nasm_strdup(numbuf
);
5488 tok
->type
= TOK_NUMBER
;