1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2011 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 */
218 bool plus
; /* is the last parameter greedy? */
219 bool nolist
; /* is this expansion listing-inhibited? */
220 Token
*dlist
; /* all defaults as one list */
221 Token
**defaults
; /* parameter default pointers */
222 int ndefs
; /* number of default parameters */
224 int prepend
; /* label prepend state */
228 int linecount
; /* number of lines within expansion */
230 int64_t def_depth
; /* current number of definition pairs deep */
231 int64_t cur_depth
; /* current number of expansions */
232 int64_t max_depth
; /* maximum number of expansions allowed */
234 int state
; /* condition state */
235 bool ignoring
; /* ignoring definition lines */
239 * Store the invocation of an expansion.
241 * The `prev' field is for the `istk->expansion` linked-list.
243 * When an expansion is being expanded, `params', `iline', `nparam',
244 * `paramlen', `rotate' and `unique' are local to the invocation.
247 ExpInv
*prev
; /* previous invocation */
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 */
261 int lineno
; /* current line number in expansion */
262 int linnum
; /* line number at invocation */
263 int relno
; /* relative line number at invocation */
264 enum pp_exp_type type
; /* expansion type */
269 * To handle an arbitrary level of file inclusion, we maintain a
270 * stack (ie linked list) of these things.
284 * Include search path. This is simply a list of strings which get
285 * prepended, in turn, to the name of an include file, in an
286 * attempt to find the file if it's not in the current directory.
294 * Conditional assembly: we maintain a separate stack of these for
295 * each level of file inclusion. (The only reason we keep the
296 * stacks separate is to ensure that a stray `%endif' in a file
297 * included from within the true branch of a `%if' won't terminate
298 * it and cause confusion: instead, rightly, it'll cause an error.)
302 * These states are for use just after %if or %elif: IF_TRUE
303 * means the condition has evaluated to truth so we are
304 * currently emitting, whereas IF_FALSE means we are not
305 * currently emitting but will start doing so if a %else comes
306 * up. In these states, all directives are admissible: %elif,
307 * %else and %endif. (And of course %if.)
309 COND_IF_TRUE
, COND_IF_FALSE
,
311 * These states come up after a %else: ELSE_TRUE means we're
312 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
313 * any %elif or %else will cause an error.
315 COND_ELSE_TRUE
, COND_ELSE_FALSE
,
317 * These states mean that we're not emitting now, and also that
318 * nothing until %endif will be emitted at all. COND_DONE is
319 * used when we've had our moment of emission
320 * and have now started seeing %elifs. COND_NEVER is used when
321 * the condition construct in question is contained within a
322 * non-emitting branch of a larger condition construct,
323 * or if there is an error.
325 COND_DONE
, COND_NEVER
329 * These defines are used as the possible return values for do_directive
331 #define NO_DIRECTIVE_FOUND 0
332 #define DIRECTIVE_FOUND 1
335 * This define sets the upper limit for smacro and expansions
337 #define DEADMAN_LIMIT (1 << 20)
340 #define REP_LIMIT ((INT64_C(1) << 62))
343 * Condition codes. Note that we use c_ prefix not C_ because C_ is
344 * used in nasm.h for the "real" condition codes. At _this_ level,
345 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
346 * ones, so we need a different enum...
348 static const char * const conditions
[] = {
349 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
350 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
351 "np", "ns", "nz", "o", "p", "pe", "po", "rcxz", "s", "z"
354 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_CXZ
, c_E
, c_ECXZ
, c_G
, c_GE
, c_L
, c_LE
,
355 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, c_NE
, c_NG
, c_NGE
, c_NL
, c_NLE
, c_NO
,
356 c_NP
, c_NS
, c_NZ
, c_O
, c_P
, c_PE
, c_PO
, c_RCXZ
, c_S
, c_Z
,
359 static const enum pp_conds inverse_ccs
[] = {
360 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, -1, c_NE
, -1, c_NG
, c_NGE
, c_NL
, c_NLE
,
361 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
,
362 c_Z
, c_NO
, c_NP
, c_PO
, c_PE
, -1, c_NS
, c_NZ
365 /* For TASM compatibility we need to be able to recognise TASM compatible
366 * conditional compilation directives. Using the NASM pre-processor does
367 * not work, so we look for them specifically from the following list and
368 * then jam in the equivalent NASM directive into the input stream.
372 TM_ARG
, TM_ELIF
, TM_ELSE
, TM_ENDIF
, TM_IF
, TM_IFDEF
, TM_IFDIFI
,
373 TM_IFNDEF
, TM_INCLUDE
, TM_LOCAL
376 static const char * const tasm_directives
[] = {
377 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
378 "ifndef", "include", "local"
381 static int StackSize
= 4;
382 static char *StackPointer
= "ebp";
383 static int ArgOffset
= 8;
384 static int LocalOffset
= 0;
386 static Context
*cstk
;
387 static Include
*istk
;
388 static IncPath
*ipath
= NULL
;
390 static int pass
; /* HACK: pass 0 = generate dependencies only */
391 static StrList
**dephead
, **deptail
; /* Dependency list */
393 static uint64_t unique
; /* unique identifier numbers */
395 static Line
*predef
= NULL
;
396 static bool do_predef
;
398 static ListGen
*list
;
401 * The current set of expansion definitions we have defined.
403 static struct hash_table expdefs
;
406 * The current set of single-line macros we have defined.
408 static struct hash_table smacros
;
411 * Linked List of all active expansion definitions
413 struct ExpDef
*expansions
= NULL
;
416 * The expansion we are currently defining
418 static ExpDef
*defining
= NULL
;
420 static uint64_t nested_mac_count
;
421 static uint64_t nested_rep_count
;
424 * Linked-list of lines to preprocess, prior to cleanup
426 static Line
*finals
= NULL
;
427 static bool in_final
= false;
430 * The number of macro parameters to allocate space for at a time.
432 #define PARAM_DELTA 16
435 * The standard macro set: defined in macros.c in the array nasm_stdmac.
436 * This gives our position in the macro set, when we're processing it.
438 static macros_t
*stdmacpos
;
441 * The extra standard macros that come from the object format, if
444 static macros_t
*extrastdmac
= NULL
;
445 static bool any_extrastdmac
;
448 * Tokens are allocated in blocks to improve speed
450 #define TOKEN_BLOCKSIZE 4096
451 static Token
*freeTokens
= NULL
;
457 static Blocks blocks
= { NULL
, NULL
};
460 * Forward declarations.
462 static Token
*expand_mmac_params(Token
* tline
);
463 static Token
*expand_smacro(Token
* tline
);
464 static Token
*expand_id(Token
* tline
);
465 static Context
*get_ctx(const char *name
, const char **namep
);
466 static void make_tok_num(Token
* tok
, int64_t val
);
467 static void error(int severity
, const char *fmt
, ...);
468 static void error_precond(int severity
, const char *fmt
, ...);
469 static void *new_Block(size_t size
);
470 static void delete_Blocks(void);
471 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
472 const char *text
, int txtlen
);
473 static Token
*copy_Token(Token
* tline
);
474 static Token
*delete_Token(Token
* t
);
475 static Line
*new_Line(void);
476 static ExpDef
*new_ExpDef(int exp_type
);
477 static ExpInv
*new_ExpInv(int exp_type
, ExpDef
*ed
);
480 * Macros for safe checking of token pointers, avoid *(NULL)
482 #define tok_type_(x,t) ((x) && (x)->type == (t))
483 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
484 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
485 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
488 * A few helpers for single macros
491 /* We might be not smacro parameter at all */
492 static bool is_smacro_param(Token
*t
)
494 return t
->type
>= TOK_SMAC_PARAM
;
497 /* smacro parameters are counted in a special way */
498 static int smacro_get_param_idx(Token
*t
)
500 return t
->type
- TOK_SMAC_PARAM
;
503 /* encode smacro parameter index */
504 static int smacro_set_param_idx(Token
*t
, unsigned int index
)
506 return t
->type
= TOK_SMAC_PARAM
+ index
;
511 #define stringify(x) #x
513 #define nasm_trace(msg, ...) printf("(%s:%d): " msg "\n", __func__, __LINE__, ##__VA_ARGS__)
514 #define nasm_dump_token(t) nasm_raw_dump_token(t, __FILE__, __LINE__, __func__);
515 #define nasm_dump_stream(t) nasm_raw_dump_stream(t, __FILE__, __LINE__, __func__);
517 /* FIXME: we really need some compound type here instead of inplace code */
518 static const char *nasm_get_tok_type_str(enum pp_token_type type
)
520 #define SWITCH_TOK_NAME(type) \
522 return stringify(type)
525 SWITCH_TOK_NAME(TOK_NONE
);
526 SWITCH_TOK_NAME(TOK_WHITESPACE
);
527 SWITCH_TOK_NAME(TOK_COMMENT
);
528 SWITCH_TOK_NAME(TOK_ID
);
529 SWITCH_TOK_NAME(TOK_PREPROC_ID
);
530 SWITCH_TOK_NAME(TOK_STRING
);
531 SWITCH_TOK_NAME(TOK_NUMBER
);
532 SWITCH_TOK_NAME(TOK_FLOAT
);
533 SWITCH_TOK_NAME(TOK_SMAC_END
);
534 SWITCH_TOK_NAME(TOK_OTHER
);
535 SWITCH_TOK_NAME(TOK_INTERNAL_STRING
);
536 SWITCH_TOK_NAME(TOK_PREPROC_Q
);
537 SWITCH_TOK_NAME(TOK_PREPROC_QQ
);
538 SWITCH_TOK_NAME(TOK_PASTE
);
539 SWITCH_TOK_NAME(TOK_INDIRECT
);
540 SWITCH_TOK_NAME(TOK_SMAC_PARAM
);
541 SWITCH_TOK_NAME(TOK_MAX
);
547 static void nasm_raw_dump_token(Token
*token
, const char *file
, int line
, const char *func
)
549 printf("---[%s (%s:%d): %p]---\n", func
, file
, line
, (void *)token
);
552 list_for_each(t
, token
) {
554 printf("'%s'(%s) ", t
->text
,
555 nasm_get_tok_type_str(t
->type
));
561 static void nasm_raw_dump_stream(Token
*token
, const char *file
, int line
, const char *func
)
563 printf("---[%s (%s:%d): %p]---\n", func
, file
, line
, (void *)token
);
566 list_for_each(t
, token
)
567 printf("%s", t
->text
? t
->text
: " ");
573 #define nasm_trace(msg, ...)
574 #define nasm_dump_token(t)
575 #define nasm_dump_stream(t)
579 * nasm_unquote with error if the string contains NUL characters.
580 * If the string contains NUL characters, issue an error and return
581 * the C len, i.e. truncate at the NUL.
583 static size_t nasm_unquote_cstr(char *qstr
, enum preproc_token directive
)
585 size_t len
= nasm_unquote(qstr
, NULL
);
586 size_t clen
= strlen(qstr
);
589 error(ERR_NONFATAL
, "NUL character in `%s' directive",
590 pp_directives
[directive
]);
596 * In-place reverse a list of tokens.
598 static Token
*reverse_tokens(Token
*t
)
602 list_reverse(t
, prev
, next
);
608 * Handle TASM specific directives, which do not contain a % in
609 * front of them. We do it here because I could not find any other
610 * place to do it for the moment, and it is a hack (ideally it would
611 * be nice to be able to use the NASM pre-processor to do it).
613 static char *check_tasm_directive(char *line
)
615 int32_t i
, j
, k
, m
, len
;
616 char *p
, *q
, *oldline
, oldchar
;
618 p
= nasm_skip_spaces(line
);
620 /* Binary search for the directive name */
622 j
= ARRAY_SIZE(tasm_directives
);
623 q
= nasm_skip_word(p
);
630 m
= nasm_stricmp(p
, tasm_directives
[k
]);
632 /* We have found a directive, so jam a % in front of it
633 * so that NASM will then recognise it as one if it's own.
638 line
= nasm_malloc(len
+ 2);
640 if (k
== TM_IFDIFI
) {
642 * NASM does not recognise IFDIFI, so we convert
643 * it to %if 0. This is not used in NASM
644 * compatible code, but does need to parse for the
645 * TASM macro package.
647 strcpy(line
+ 1, "if 0");
649 memcpy(line
+ 1, p
, len
+ 1);
664 * The pre-preprocessing stage... This function translates line
665 * number indications as they emerge from GNU cpp (`# lineno "file"
666 * flags') into NASM preprocessor line number indications (`%line
669 static char *prepreproc(char *line
)
672 char *fname
, *oldline
;
674 if (line
[0] == '#' && line
[1] == ' ') {
677 lineno
= atoi(fname
);
678 fname
+= strspn(fname
, "0123456789 ");
681 fnlen
= strcspn(fname
, "\"");
682 line
= nasm_malloc(20 + fnlen
);
683 snprintf(line
, 20 + fnlen
, "%%line %d %.*s", lineno
, fnlen
, fname
);
686 if (tasm_compatible_mode
)
687 return check_tasm_directive(line
);
692 * Free a linked list of tokens.
694 static void free_tlist(Token
* list
)
697 list
= delete_Token(list
);
701 * Free a linked list of lines.
703 static void free_llist(Line
* list
)
706 list_for_each_safe(l
, tmp
, list
) {
707 free_tlist(l
->first
);
715 static void free_expdef(ExpDef
* ed
)
718 free_tlist(ed
->dlist
);
719 nasm_free(ed
->defaults
);
720 free_llist(ed
->line
);
727 static void free_expinv(ExpInv
* ei
)
730 nasm_free(ei
->label_text
);
735 * Free all currently defined macros, and free the hash tables
737 static void free_smacro_table(struct hash_table
*smt
)
741 struct hash_tbl_node
*it
= NULL
;
743 while ((s
= hash_iterate(smt
, &it
, &key
)) != NULL
) {
744 nasm_free((void *)key
);
745 list_for_each_safe(s
, tmp
, s
) {
747 free_tlist(s
->expansion
);
754 static void free_expdef_table(struct hash_table
*edt
)
758 struct hash_tbl_node
*it
= NULL
;
761 while ((ed
= hash_iterate(edt
, &it
, &key
)) != NULL
) {
762 nasm_free((void *)key
);
763 list_for_each_safe(ed
,tmp
, ed
)
769 static void free_macros(void)
771 free_smacro_table(&smacros
);
772 free_expdef_table(&expdefs
);
776 * Initialize the hash tables
778 static void init_macros(void)
780 hash_init(&smacros
, HASH_LARGE
);
781 hash_init(&expdefs
, HASH_LARGE
);
785 * Pop the context stack.
787 static void ctx_pop(void)
792 free_smacro_table(&c
->localmac
);
798 * Search for a key in the hash index; adding it if necessary
799 * (in which case we initialize the data pointer to NULL.)
802 hash_findi_add(struct hash_table
*hash
, const char *str
)
804 struct hash_insert hi
;
808 r
= hash_findi(hash
, str
, &hi
);
812 strx
= nasm_strdup(str
); /* Use a more efficient allocator here? */
813 return hash_add(&hi
, strx
, NULL
);
817 * Like hash_findi, but returns the data element rather than a pointer
818 * to it. Used only when not adding a new element, hence no third
822 hash_findix(struct hash_table
*hash
, const char *str
)
826 p
= hash_findi(hash
, str
, NULL
);
827 return p
? *p
: NULL
;
831 * read line from standard macros set,
832 * if there no more left -- return NULL
834 static char *line_from_stdmac(void)
837 const unsigned char *p
= stdmacpos
;
846 len
+= pp_directives_len
[c
- 0x80] + 1;
851 line
= nasm_malloc(len
+ 1);
853 while ((c
= *stdmacpos
++)) {
855 memcpy(q
, pp_directives
[c
- 0x80], pp_directives_len
[c
- 0x80]);
856 q
+= pp_directives_len
[c
- 0x80];
866 /* This was the last of the standard macro chain... */
868 if (any_extrastdmac
) {
869 stdmacpos
= extrastdmac
;
870 any_extrastdmac
= false;
871 } else if (do_predef
) {
874 Token
*head
, **tail
, *t
;
877 * Nasty hack: here we push the contents of
878 * `predef' on to the top-level expansion stack,
879 * since this is the most convenient way to
880 * implement the pre-include and pre-define
883 list_for_each(pd
, predef
) {
886 list_for_each(t
, pd
->first
) {
887 *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
888 tail
= &(*tail
)->next
;
893 ei
= new_ExpInv(EXP_PREDEF
, NULL
);
896 ei
->prev
= istk
->expansion
;
897 istk
->expansion
= ei
;
906 #define BUF_DELTA 512
908 * Read a line from the top file in istk, handling multiple CR/LFs
909 * at the end of the line read, and handling spurious ^Zs. Will
910 * return lines from the standard macro set if this has not already
913 static char *read_line(void)
915 char *buffer
, *p
, *q
;
916 int bufsize
, continued_count
;
919 * standart macros set (predefined) goes first
921 p
= line_from_stdmac();
926 * regular read from a file
929 buffer
= nasm_malloc(BUF_DELTA
);
933 q
= fgets(p
, bufsize
- (p
- buffer
), istk
->fp
);
937 if (p
> buffer
&& p
[-1] == '\n') {
939 * Convert backslash-CRLF line continuation sequences into
940 * nothing at all (for DOS and Windows)
942 if (((p
- 2) > buffer
) && (p
[-3] == '\\') && (p
[-2] == '\r')) {
948 * Also convert backslash-LF line continuation sequences into
949 * nothing at all (for Unix)
951 else if (((p
- 1) > buffer
) && (p
[-2] == '\\')) {
959 if (p
- buffer
> bufsize
- 10) {
960 int32_t offset
= p
- buffer
;
961 bufsize
+= BUF_DELTA
;
962 buffer
= nasm_realloc(buffer
, bufsize
);
963 p
= buffer
+ offset
; /* prevent stale-pointer problems */
967 if (!q
&& p
== buffer
) {
972 src_set_linnum(src_get_linnum() + istk
->lineinc
+
973 (continued_count
* istk
->lineinc
));
976 * Play safe: remove CRs as well as LFs, if any of either are
977 * present at the end of the line.
979 while (--p
>= buffer
&& (*p
== '\n' || *p
== '\r'))
983 * Handle spurious ^Z, which may be inserted into source files
984 * by some file transfer utilities.
986 buffer
[strcspn(buffer
, "\032")] = '\0';
988 list
->line(LIST_READ
, buffer
);
994 * Tokenize a line of text. This is a very simple process since we
995 * don't need to parse the value out of e.g. numeric tokens: we
996 * simply split one string into many.
998 static Token
*tokenize(char *line
)
1001 enum pp_token_type type
;
1003 Token
*t
, **tail
= &list
;
1004 bool verbose
= true;
1006 nasm_trace("Tokenize for '%s'", line
);
1008 if ((defining
!= NULL
) && (defining
->ignoring
== true)) {
1016 if (*p
== '+' && !nasm_isdigit(p
[1])) {
1019 } else if (nasm_isdigit(*p
) ||
1020 ((*p
== '-' || *p
== '+') && nasm_isdigit(p
[1]))) {
1024 while (nasm_isdigit(*p
));
1025 type
= TOK_PREPROC_ID
;
1026 } else if (*p
== '{') {
1028 while (*p
&& *p
!= '}') {
1035 type
= TOK_PREPROC_ID
;
1036 } else if (*p
== '[') {
1038 line
+= 2; /* Skip the leading %[ */
1040 while (lvl
&& (c
= *p
++)) {
1052 p
= nasm_skip_string(p
- 1) + 1;
1062 error(ERR_NONFATAL
, "unterminated %[ construct");
1063 type
= TOK_INDIRECT
;
1064 } else if (*p
== '?') {
1065 type
= TOK_PREPROC_Q
; /* %? */
1068 type
= TOK_PREPROC_QQ
; /* %?? */
1071 } else if (*p
== '!') {
1072 type
= TOK_PREPROC_ID
;
1077 } while (isidchar(*p
));
1078 } else if (*p
== '\'' || *p
== '\"' || *p
== '`') {
1079 p
= nasm_skip_string(p
);
1083 error(ERR_NONFATAL
|ERR_PASS1
, "unterminated %! string");
1085 /* %! without string or identifier */
1086 type
= TOK_OTHER
; /* Legacy behavior... */
1088 } else if (isidchar(*p
) ||
1089 ((*p
== '!' || *p
== '%' || *p
== '$') &&
1094 while (isidchar(*p
));
1095 type
= TOK_PREPROC_ID
;
1101 } else if (isidstart(*p
) || (*p
== '$' && isidstart(p
[1]))) {
1104 while (*p
&& isidchar(*p
))
1106 } else if (*p
== '\'' || *p
== '"' || *p
== '`') {
1111 p
= nasm_skip_string(p
);
1115 } else if(verbose
) {
1116 error(ERR_WARNING
|ERR_PASS1
, "unterminated string");
1117 /* Handling unterminated strings by UNV */
1120 } else if (p
[0] == '$' && p
[1] == '$') {
1121 type
= TOK_OTHER
; /* TOKEN_BASE */
1123 } else if (isnumstart(*p
)) {
1124 bool is_hex
= false;
1125 bool is_float
= false;
1141 if (!is_hex
&& (c
== 'e' || c
== 'E')) {
1143 if (*p
== '+' || *p
== '-') {
1145 * e can only be followed by +/- if it is either a
1146 * prefixed hex number or a floating-point number
1151 } else if (c
== 'H' || c
== 'h' || c
== 'X' || c
== 'x') {
1153 } else if (c
== 'P' || c
== 'p') {
1155 if (*p
== '+' || *p
== '-')
1157 } else if (isnumchar(c
) || c
== '_')
1158 ; /* just advance */
1159 else if (c
== '.') {
1161 * we need to deal with consequences of the legacy
1162 * parser, like "1.nolist" being two tokens
1163 * (TOK_NUMBER, TOK_ID) here; at least give it
1164 * a shot for now. In the future, we probably need
1165 * a flex-based scanner with proper pattern matching
1166 * to do it as well as it can be done. Nothing in
1167 * the world is going to help the person who wants
1168 * 0x123.p16 interpreted as two tokens, though.
1174 if (nasm_isdigit(*r
) || (is_hex
&& nasm_isxdigit(*r
)) ||
1175 (!is_hex
&& (*r
== 'e' || *r
== 'E')) ||
1176 (*r
== 'p' || *r
== 'P')) {
1180 break; /* Terminate the token */
1184 p
--; /* Point to first character beyond number */
1186 if (p
== line
+1 && *line
== '$') {
1187 type
= TOK_OTHER
; /* TOKEN_HERE */
1189 if (has_e
&& !is_hex
) {
1190 /* 1e13 is floating-point, but 1e13h is not */
1194 type
= is_float
? TOK_FLOAT
: TOK_NUMBER
;
1196 } else if (nasm_isspace(*p
)) {
1197 type
= TOK_WHITESPACE
;
1198 p
= nasm_skip_spaces(p
);
1200 * Whitespace just before end-of-line is discarded by
1201 * pretending it's a comment; whitespace just before a
1202 * comment gets lumped into the comment.
1204 if (!*p
|| *p
== ';') {
1209 } else if (*p
== ';') {
1215 * Anything else is an operator of some kind. We check
1216 * for all the double-character operators (>>, <<, //,
1217 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
1218 * else is a single-character operator.
1221 if ((p
[0] == '>' && p
[1] == '>') ||
1222 (p
[0] == '<' && p
[1] == '<') ||
1223 (p
[0] == '/' && p
[1] == '/') ||
1224 (p
[0] == '<' && p
[1] == '=') ||
1225 (p
[0] == '>' && p
[1] == '=') ||
1226 (p
[0] == '=' && p
[1] == '=') ||
1227 (p
[0] == '!' && p
[1] == '=') ||
1228 (p
[0] == '<' && p
[1] == '>') ||
1229 (p
[0] == '&' && p
[1] == '&') ||
1230 (p
[0] == '|' && p
[1] == '|') ||
1231 (p
[0] == '^' && p
[1] == '^')) {
1237 /* Handling unterminated string by UNV */
1240 *tail = t = new_Token(NULL, TOK_STRING, line, p-line+1);
1241 t->text[p-line] = *line;
1245 if (type
!= TOK_COMMENT
) {
1246 *tail
= t
= new_Token(NULL
, type
, line
, p
- line
);
1252 nasm_dump_token(list
);
1258 * this function allocates a new managed block of memory and
1259 * returns a pointer to the block. The managed blocks are
1260 * deleted only all at once by the delete_Blocks function.
1262 static void *new_Block(size_t size
)
1264 Blocks
*b
= &blocks
;
1266 /* first, get to the end of the linked list */
1270 /* now allocate the requested chunk */
1271 b
->chunk
= nasm_malloc(size
);
1273 /* now allocate a new block for the next request */
1274 b
->next
= nasm_zalloc(sizeof(Blocks
));
1280 * this function deletes all managed blocks of memory
1282 static void delete_Blocks(void)
1284 Blocks
*a
, *b
= &blocks
;
1287 * keep in mind that the first block, pointed to by blocks
1288 * is a static and not dynamically allocated, so we don't
1292 nasm_free(b
->chunk
);
1301 * this function creates a new Token and passes a pointer to it
1302 * back to the caller. It sets the type and text elements, and
1303 * also the a.mac and next elements to NULL.
1305 static Token
*new_Token(Token
* next
, enum pp_token_type type
,
1306 const char *text
, int txtlen
)
1312 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
1313 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
1314 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
1315 freeTokens
[i
].next
= NULL
;
1318 freeTokens
= t
->next
;
1322 if (type
== TOK_WHITESPACE
|| !text
) {
1326 txtlen
= strlen(text
);
1327 t
->text
= nasm_malloc(txtlen
+1);
1328 memcpy(t
->text
, text
, txtlen
);
1329 t
->text
[txtlen
] = '\0';
1334 static Token
*copy_Token(Token
* tline
)
1336 Token
*t
, *tt
, *first
= NULL
, *prev
= NULL
;
1338 for (tt
= tline
; tt
!= NULL
; tt
= tt
->next
) {
1340 freeTokens
= (Token
*) new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
1341 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
1342 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
1343 freeTokens
[i
].next
= NULL
;
1346 freeTokens
= t
->next
;
1348 t
->text
= tt
->text
? nasm_strdup(tt
->text
) : NULL
;
1349 t
->a
.mac
= tt
->a
.mac
;
1350 t
->a
.len
= tt
->a
.len
;
1362 static Token
*delete_Token(Token
* t
)
1364 Token
*next
= t
->next
;
1366 t
->next
= freeTokens
;
1372 * Convert a line of tokens back into text.
1373 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1374 * will be transformed into ..@ctxnum.xxx
1376 static char *detoken(Token
* tlist
, bool expand_locals
)
1383 list_for_each(t
, tlist
) {
1384 if (t
->type
== TOK_PREPROC_ID
&& t
->text
[1] == '!') {
1389 if (*v
== '\'' || *v
== '\"' || *v
== '`') {
1390 size_t len
= nasm_unquote(v
, NULL
);
1391 size_t clen
= strlen(v
);
1394 error(ERR_NONFATAL
| ERR_PASS1
,
1395 "NUL character in %! string");
1401 char *p
= getenv(v
);
1403 error(ERR_NONFATAL
| ERR_PASS1
,
1404 "nonexistent environment variable `%s'", v
);
1407 t
->text
= nasm_strdup(p
);
1412 /* Expand local macros here and not during preprocessing */
1413 if (expand_locals
&&
1414 t
->type
== TOK_PREPROC_ID
&& t
->text
&&
1415 t
->text
[0] == '%' && t
->text
[1] == '$') {
1418 Context
*ctx
= get_ctx(t
->text
, &q
);
1421 snprintf(buffer
, sizeof(buffer
), "..@%"PRIu32
".", ctx
->number
);
1422 p
= nasm_strcat(buffer
, q
);
1428 /* Expand %? and %?? directives */
1429 if ((istk
->expansion
!= NULL
) &&
1430 ((t
->type
== TOK_PREPROC_Q
) ||
1431 (t
->type
== TOK_PREPROC_QQ
))) {
1433 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
){
1434 if (ei
->type
== EXP_MMACRO
) {
1436 if (t
->type
== TOK_PREPROC_Q
) {
1437 t
->text
= nasm_strdup(ei
->name
);
1439 t
->text
= nasm_strdup(ei
->def
->name
);
1446 if (t
->type
== TOK_WHITESPACE
)
1449 len
+= strlen(t
->text
);
1452 p
= line
= nasm_malloc(len
+ 1);
1454 list_for_each(t
, tlist
) {
1455 if (t
->type
== TOK_WHITESPACE
) {
1457 } else if (t
->text
) {
1469 * Initialize a new Line
1471 static inline Line
*new_Line(void)
1473 return (Line
*)nasm_zalloc(sizeof(Line
));
1478 * Initialize a new Expansion Definition
1480 static ExpDef
*new_ExpDef(int exp_type
)
1482 ExpDef
*ed
= (ExpDef
*)nasm_zalloc(sizeof(ExpDef
));
1483 ed
->type
= exp_type
;
1484 ed
->casesense
= true;
1485 ed
->state
= COND_NEVER
;
1492 * Initialize a new Expansion Instance
1494 static ExpInv
*new_ExpInv(int exp_type
, ExpDef
*ed
)
1496 ExpInv
*ei
= (ExpInv
*)nasm_zalloc(sizeof(ExpInv
));
1497 ei
->type
= exp_type
;
1499 ei
->unique
= ++unique
;
1501 if ((istk
->mmac_depth
< 1) &&
1502 (istk
->expansion
== NULL
) &&
1504 (ed
->type
!= EXP_MMACRO
) &&
1505 (ed
->type
!= EXP_REP
) &&
1506 (ed
->type
!= EXP_WHILE
)) {
1507 ei
->linnum
= src_get_linnum();
1508 src_set_linnum(ei
->linnum
- ed
->linecount
- 1);
1512 if ((istk
->expansion
== NULL
) ||
1513 (ei
->type
== EXP_MMACRO
)) {
1516 ei
->relno
= istk
->expansion
->lineno
;
1518 ei
->relno
-= (ed
->linecount
+ 1);
1525 * A scanner, suitable for use by the expression evaluator, which
1526 * operates on a line of Tokens. Expects a pointer to a pointer to
1527 * the first token in the line to be passed in as its private_data
1530 * FIX: This really needs to be unified with stdscan.
1532 static int ppscan(void *private_data
, struct tokenval
*tokval
)
1534 Token
**tlineptr
= private_data
;
1536 char ourcopy
[MAX_KEYWORD
+1], *p
, *r
, *s
;
1540 *tlineptr
= tline
? tline
->next
: NULL
;
1541 } while (tline
&& (tline
->type
== TOK_WHITESPACE
||
1542 tline
->type
== TOK_COMMENT
));
1545 return tokval
->t_type
= TOKEN_EOS
;
1547 tokval
->t_charptr
= tline
->text
;
1549 if (tline
->text
[0] == '$' && !tline
->text
[1])
1550 return tokval
->t_type
= TOKEN_HERE
;
1551 if (tline
->text
[0] == '$' && tline
->text
[1] == '$' && !tline
->text
[2])
1552 return tokval
->t_type
= TOKEN_BASE
;
1554 if (tline
->type
== TOK_ID
) {
1555 p
= tokval
->t_charptr
= tline
->text
;
1557 tokval
->t_charptr
++;
1558 return tokval
->t_type
= TOKEN_ID
;
1561 for (r
= p
, s
= ourcopy
; *r
; r
++) {
1562 if (r
>= p
+MAX_KEYWORD
)
1563 return tokval
->t_type
= TOKEN_ID
; /* Not a keyword */
1564 *s
++ = nasm_tolower(*r
);
1567 /* right, so we have an identifier sitting in temp storage. now,
1568 * is it actually a register or instruction name, or what? */
1569 return nasm_token_hash(ourcopy
, tokval
);
1572 if (tline
->type
== TOK_NUMBER
) {
1574 tokval
->t_integer
= readnum(tline
->text
, &rn_error
);
1575 tokval
->t_charptr
= tline
->text
;
1577 return tokval
->t_type
= TOKEN_ERRNUM
;
1579 return tokval
->t_type
= TOKEN_NUM
;
1582 if (tline
->type
== TOK_FLOAT
) {
1583 return tokval
->t_type
= TOKEN_FLOAT
;
1586 if (tline
->type
== TOK_STRING
) {
1589 bq
= tline
->text
[0];
1590 tokval
->t_charptr
= tline
->text
;
1591 tokval
->t_inttwo
= nasm_unquote(tline
->text
, &ep
);
1593 if (ep
[0] != bq
|| ep
[1] != '\0')
1594 return tokval
->t_type
= TOKEN_ERRSTR
;
1596 return tokval
->t_type
= TOKEN_STR
;
1599 if (tline
->type
== TOK_OTHER
) {
1600 if (!strcmp(tline
->text
, "<<"))
1601 return tokval
->t_type
= TOKEN_SHL
;
1602 if (!strcmp(tline
->text
, ">>"))
1603 return tokval
->t_type
= TOKEN_SHR
;
1604 if (!strcmp(tline
->text
, "//"))
1605 return tokval
->t_type
= TOKEN_SDIV
;
1606 if (!strcmp(tline
->text
, "%%"))
1607 return tokval
->t_type
= TOKEN_SMOD
;
1608 if (!strcmp(tline
->text
, "=="))
1609 return tokval
->t_type
= TOKEN_EQ
;
1610 if (!strcmp(tline
->text
, "<>"))
1611 return tokval
->t_type
= TOKEN_NE
;
1612 if (!strcmp(tline
->text
, "!="))
1613 return tokval
->t_type
= TOKEN_NE
;
1614 if (!strcmp(tline
->text
, "<="))
1615 return tokval
->t_type
= TOKEN_LE
;
1616 if (!strcmp(tline
->text
, ">="))
1617 return tokval
->t_type
= TOKEN_GE
;
1618 if (!strcmp(tline
->text
, "&&"))
1619 return tokval
->t_type
= TOKEN_DBL_AND
;
1620 if (!strcmp(tline
->text
, "^^"))
1621 return tokval
->t_type
= TOKEN_DBL_XOR
;
1622 if (!strcmp(tline
->text
, "||"))
1623 return tokval
->t_type
= TOKEN_DBL_OR
;
1627 * We have no other options: just return the first character of
1630 return tokval
->t_type
= tline
->text
[0];
1634 * Compare a string to the name of an existing macro; this is a
1635 * simple wrapper which calls either strcmp or nasm_stricmp
1636 * depending on the value of the `casesense' parameter.
1638 static int mstrcmp(const char *p
, const char *q
, bool casesense
)
1640 return casesense
? strcmp(p
, q
) : nasm_stricmp(p
, q
);
1644 * Compare a string to the name of an existing macro; this is a
1645 * simple wrapper which calls either strcmp or nasm_stricmp
1646 * depending on the value of the `casesense' parameter.
1648 static int mmemcmp(const char *p
, const char *q
, size_t l
, bool casesense
)
1650 return casesense
? memcmp(p
, q
, l
) : nasm_memicmp(p
, q
, l
);
1654 * Return the Context structure associated with a %$ token. Return
1655 * NULL, having _already_ reported an error condition, if the
1656 * context stack isn't deep enough for the supplied number of $
1659 * If "namep" is non-NULL, set it to the pointer to the macro name
1660 * tail, i.e. the part beyond %$...
1662 static Context
*get_ctx(const char *name
, const char **namep
)
1670 if (!name
|| name
[0] != '%' || name
[1] != '$')
1674 error(ERR_NONFATAL
, "`%s': context stack is empty", name
);
1681 while (ctx
&& *name
== '$') {
1688 error(ERR_NONFATAL
, "`%s': context stack is only"
1689 " %d level%s deep", name
, i
, (i
== 1 ? "" : "s"));
1700 * Check to see if a file is already in a string list
1702 static bool in_list(const StrList
*list
, const char *str
)
1705 if (!strcmp(list
->str
, str
))
1713 * Open an include file. This routine must always return a valid
1714 * file pointer if it returns - it's responsible for throwing an
1715 * ERR_FATAL and bombing out completely if not. It should also try
1716 * the include path one by one until it finds the file or reaches
1717 * the end of the path.
1719 static FILE *inc_fopen(const char *file
, StrList
**dhead
, StrList
***dtail
,
1724 IncPath
*ip
= ipath
;
1725 int len
= strlen(file
);
1726 size_t prefix_len
= 0;
1730 sl
= nasm_malloc(prefix_len
+len
+1+sizeof sl
->next
);
1732 memcpy(sl
->str
, prefix
, prefix_len
);
1733 memcpy(sl
->str
+prefix_len
, file
, len
+1);
1734 fp
= fopen(sl
->str
, "r");
1735 if (fp
&& dhead
&& !in_list(*dhead
, sl
->str
)) {
1752 prefix_len
= strlen(prefix
);
1754 /* -MG given and file not found */
1755 if (dhead
&& !in_list(*dhead
, file
)) {
1756 sl
= nasm_malloc(len
+1+sizeof sl
->next
);
1758 strcpy(sl
->str
, file
);
1766 error(ERR_FATAL
, "unable to open include file `%s'", file
);
1771 * Determine if we should warn on defining a single-line macro of
1772 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1773 * return true if _any_ single-line macro of that name is defined.
1774 * Otherwise, will return true if a single-line macro with either
1775 * `nparam' or no parameters is defined.
1777 * If a macro with precisely the right number of parameters is
1778 * defined, or nparam is -1, the address of the definition structure
1779 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1780 * is NULL, no action will be taken regarding its contents, and no
1783 * Note that this is also called with nparam zero to resolve
1786 * If you already know which context macro belongs to, you can pass
1787 * the context pointer as first parameter; if you won't but name begins
1788 * with %$ the context will be automatically computed. If all_contexts
1789 * is true, macro will be searched in outer contexts as well.
1792 smacro_defined(Context
* ctx
, const char *name
, int nparam
, SMacro
** defn
,
1795 struct hash_table
*smtbl
;
1799 smtbl
= &ctx
->localmac
;
1800 } else if (name
[0] == '%' && name
[1] == '$') {
1802 ctx
= get_ctx(name
, &name
);
1804 return false; /* got to return _something_ */
1805 smtbl
= &ctx
->localmac
;
1809 m
= (SMacro
*) hash_findix(smtbl
, name
);
1812 if (!mstrcmp(m
->name
, name
, m
->casesense
&& nocase
) &&
1813 (nparam
<= 0 || m
->nparam
== 0 || nparam
== (int) m
->nparam
)) {
1815 if (nparam
== (int) m
->nparam
|| nparam
== -1)
1829 * Count and mark off the parameters in a multi-line macro call.
1830 * This is called both from within the multi-line macro expansion
1831 * code, and also to mark off the default parameters when provided
1832 * in a %macro definition line.
1834 static void count_mmac_params(Token
* t
, int *nparam
, Token
*** params
)
1836 int paramsize
, brace
;
1838 *nparam
= paramsize
= 0;
1841 /* +1: we need space for the final NULL */
1842 if (*nparam
+1 >= paramsize
) {
1843 paramsize
+= PARAM_DELTA
;
1844 *params
= nasm_realloc(*params
, sizeof(**params
) * paramsize
);
1848 if (tok_is_(t
, "{"))
1850 (*params
)[(*nparam
)++] = t
;
1851 while (tok_isnt_(t
, brace
? "}" : ","))
1853 if (t
) { /* got a comma/brace */
1857 * Now we've found the closing brace, look further
1861 if (tok_isnt_(t
, ",")) {
1863 "braces do not enclose all of macro parameter");
1864 while (tok_isnt_(t
, ","))
1868 t
= t
->next
; /* eat the comma */
1875 * Determine whether one of the various `if' conditions is true or
1878 * We must free the tline we get passed.
1880 static bool if_condition(Token
* tline
, enum preproc_token ct
)
1882 enum pp_conditional i
= PP_COND(ct
);
1884 Token
*t
, *tt
, **tptr
, *origline
;
1885 struct tokenval tokval
;
1887 enum pp_token_type needtype
;
1894 j
= false; /* have we matched yet? */
1899 if (tline
->type
!= TOK_ID
) {
1901 "`%s' expects context identifiers", pp_directives
[ct
]);
1902 free_tlist(origline
);
1905 if (cstk
&& cstk
->name
&& !nasm_stricmp(tline
->text
, cstk
->name
))
1907 tline
= tline
->next
;
1912 j
= false; /* have we matched yet? */
1915 if (!tline
|| (tline
->type
!= TOK_ID
&&
1916 (tline
->type
!= TOK_PREPROC_ID
||
1917 tline
->text
[1] != '$'))) {
1919 "`%s' expects macro identifiers", pp_directives
[ct
]);
1922 if (smacro_defined(NULL
, tline
->text
, 0, NULL
, true))
1924 tline
= tline
->next
;
1930 tline
= expand_smacro(tline
);
1931 j
= false; /* have we matched yet? */
1934 if (!tline
|| (tline
->type
!= TOK_ID
&&
1935 tline
->type
!= TOK_STRING
&&
1936 (tline
->type
!= TOK_PREPROC_ID
||
1937 tline
->text
[1] != '!'))) {
1939 "`%s' expects environment variable names",
1944 if (tline
->type
== TOK_PREPROC_ID
)
1945 p
+= 2; /* Skip leading %! */
1946 if (*p
== '\'' || *p
== '\"' || *p
== '`')
1947 nasm_unquote_cstr(p
, ct
);
1950 tline
= tline
->next
;
1957 tline
= expand_smacro(tline
);
1959 while (tok_isnt_(tt
, ","))
1963 "`%s' expects two comma-separated arguments",
1968 j
= true; /* assume equality unless proved not */
1969 while ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) && tt
) {
1970 if (tt
->type
== TOK_OTHER
&& !strcmp(tt
->text
, ",")) {
1971 error(ERR_NONFATAL
, "`%s': more than one comma on line",
1975 if (t
->type
== TOK_WHITESPACE
) {
1979 if (tt
->type
== TOK_WHITESPACE
) {
1983 if (tt
->type
!= t
->type
) {
1984 j
= false; /* found mismatching tokens */
1987 /* When comparing strings, need to unquote them first */
1988 if (t
->type
== TOK_STRING
) {
1989 size_t l1
= nasm_unquote(t
->text
, NULL
);
1990 size_t l2
= nasm_unquote(tt
->text
, NULL
);
1996 if (mmemcmp(t
->text
, tt
->text
, l1
, i
== PPC_IFIDN
)) {
2000 } else if (mstrcmp(tt
->text
, t
->text
, i
== PPC_IFIDN
) != 0) {
2001 j
= false; /* found mismatching tokens */
2008 if ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) || tt
)
2009 j
= false; /* trailing gunk on one end or other */
2015 ExpDef searching
, *ed
;
2018 tline
= expand_id(tline
);
2019 if (!tok_type_(tline
, TOK_ID
)) {
2021 "`%s' expects a macro name", pp_directives
[ct
]);
2024 memset(&searching
, 0, sizeof(searching
));
2025 searching
.name
= nasm_strdup(tline
->text
);
2026 searching
.casesense
= true;
2027 searching
.nparam_max
= INT_MAX
;
2028 tline
= expand_smacro(tline
->next
);
2031 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
2033 "`%s' expects a parameter count or nothing",
2036 searching
.nparam_min
= searching
.nparam_max
=
2037 readnum(tline
->text
, &j
);
2040 "unable to parse parameter count `%s'",
2043 if (tline
&& tok_is_(tline
->next
, "-")) {
2044 tline
= tline
->next
->next
;
2045 if (tok_is_(tline
, "*"))
2046 searching
.nparam_max
= INT_MAX
;
2047 else if (!tok_type_(tline
, TOK_NUMBER
))
2049 "`%s' expects a parameter count after `-'",
2052 searching
.nparam_max
= readnum(tline
->text
, &j
);
2055 "unable to parse parameter count `%s'",
2057 if (searching
.nparam_min
> searching
.nparam_max
)
2059 "minimum parameter count exceeds maximum");
2062 if (tline
&& tok_is_(tline
->next
, "+")) {
2063 tline
= tline
->next
;
2064 searching
.plus
= true;
2066 ed
= (ExpDef
*) hash_findix(&expdefs
, searching
.name
);
2067 while (ed
!= NULL
) {
2068 if (!strcmp(ed
->name
, searching
.name
) &&
2069 (ed
->nparam_min
<= searching
.nparam_max
|| searching
.plus
) &&
2070 (searching
.nparam_min
<= ed
->nparam_max
|| ed
->plus
)) {
2076 if (tline
&& tline
->next
)
2077 error(ERR_WARNING
|ERR_PASS1
,
2078 "trailing garbage after %%ifmacro ignored");
2079 nasm_free(searching
.name
);
2088 needtype
= TOK_NUMBER
;
2091 needtype
= TOK_STRING
;
2095 t
= tline
= expand_smacro(tline
);
2097 while (tok_type_(t
, TOK_WHITESPACE
) ||
2098 (needtype
== TOK_NUMBER
&&
2099 tok_type_(t
, TOK_OTHER
) &&
2100 (t
->text
[0] == '-' || t
->text
[0] == '+') &&
2104 j
= tok_type_(t
, needtype
);
2108 t
= tline
= expand_smacro(tline
);
2109 while (tok_type_(t
, TOK_WHITESPACE
))
2114 t
= t
->next
; /* Skip the actual token */
2115 while (tok_type_(t
, TOK_WHITESPACE
))
2117 j
= !t
; /* Should be nothing left */
2122 t
= tline
= expand_smacro(tline
);
2123 while (tok_type_(t
, TOK_WHITESPACE
))
2126 j
= !t
; /* Should be empty */
2130 t
= tline
= expand_smacro(tline
);
2132 tokval
.t_type
= TOKEN_INVALID
;
2133 evalresult
= evaluate(ppscan
, tptr
, &tokval
,
2134 NULL
, pass
| CRITICAL
, error
, NULL
);
2138 error(ERR_WARNING
|ERR_PASS1
,
2139 "trailing garbage after expression ignored");
2140 if (!is_simple(evalresult
)) {
2142 "non-constant value given to `%s'", pp_directives
[ct
]);
2145 j
= reloc_value(evalresult
) != 0;
2150 "preprocessor directive `%s' not yet implemented",
2155 free_tlist(origline
);
2156 return j
^ PP_NEGATIVE(ct
);
2159 free_tlist(origline
);
2164 * Common code for defining an smacro
2166 static bool define_smacro(Context
*ctx
, const char *mname
, bool casesense
,
2167 int nparam
, Token
*expansion
)
2169 SMacro
*smac
, **smhead
;
2170 struct hash_table
*smtbl
;
2172 if (smacro_defined(ctx
, mname
, nparam
, &smac
, casesense
)) {
2174 error(ERR_WARNING
|ERR_PASS1
,
2175 "single-line macro `%s' defined both with and"
2176 " without parameters", mname
);
2178 * Some instances of the old code considered this a failure,
2179 * some others didn't. What is the right thing to do here?
2181 free_tlist(expansion
);
2182 return false; /* Failure */
2185 * We're redefining, so we have to take over an
2186 * existing SMacro structure. This means freeing
2187 * what was already in it.
2189 nasm_free(smac
->name
);
2190 free_tlist(smac
->expansion
);
2193 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
2194 smhead
= (SMacro
**) hash_findi_add(smtbl
, mname
);
2195 smac
= nasm_zalloc(sizeof(SMacro
));
2196 smac
->next
= *smhead
;
2199 smac
->name
= nasm_strdup(mname
);
2200 smac
->casesense
= casesense
;
2201 smac
->nparam
= nparam
;
2202 smac
->expansion
= expansion
;
2203 smac
->in_progress
= false;
2204 return true; /* Success */
2208 * Undefine an smacro
2210 static void undef_smacro(Context
*ctx
, const char *mname
)
2212 SMacro
**smhead
, *s
, **sp
;
2213 struct hash_table
*smtbl
;
2215 smtbl
= ctx
? &ctx
->localmac
: &smacros
;
2216 smhead
= (SMacro
**)hash_findi(smtbl
, mname
, NULL
);
2220 * We now have a macro name... go hunt for it.
2223 while ((s
= *sp
) != NULL
) {
2224 if (!mstrcmp(s
->name
, mname
, s
->casesense
)) {
2227 free_tlist(s
->expansion
);
2237 * Parse a mmacro specification.
2239 static bool parse_mmacro_spec(Token
*tline
, ExpDef
*def
, const char *directive
)
2243 tline
= tline
->next
;
2245 tline
= expand_id(tline
);
2246 if (!tok_type_(tline
, TOK_ID
)) {
2247 error(ERR_NONFATAL
, "`%s' expects a macro name", directive
);
2251 def
->name
= nasm_strdup(tline
->text
);
2253 def
->nolist
= false;
2254 // def->in_progress = 0;
2255 // def->rep_nest = NULL;
2256 def
->nparam_min
= 0;
2257 def
->nparam_max
= 0;
2259 tline
= expand_smacro(tline
->next
);
2261 if (!tok_type_(tline
, TOK_NUMBER
)) {
2262 error(ERR_NONFATAL
, "`%s' expects a parameter count", directive
);
2264 def
->nparam_min
= def
->nparam_max
=
2265 readnum(tline
->text
, &err
);
2268 "unable to parse parameter count `%s'", tline
->text
);
2270 if (tline
&& tok_is_(tline
->next
, "-")) {
2271 tline
= tline
->next
->next
;
2272 if (tok_is_(tline
, "*")) {
2273 def
->nparam_max
= INT_MAX
;
2274 } else if (!tok_type_(tline
, TOK_NUMBER
)) {
2276 "`%s' expects a parameter count after `-'", directive
);
2278 def
->nparam_max
= readnum(tline
->text
, &err
);
2280 error(ERR_NONFATAL
, "unable to parse parameter count `%s'",
2283 if (def
->nparam_min
> def
->nparam_max
) {
2284 error(ERR_NONFATAL
, "minimum parameter count exceeds maximum");
2288 if (tline
&& tok_is_(tline
->next
, "+")) {
2289 tline
= tline
->next
;
2292 if (tline
&& tok_type_(tline
->next
, TOK_ID
) &&
2293 !nasm_stricmp(tline
->next
->text
, ".nolist")) {
2294 tline
= tline
->next
;
2299 * Handle default parameters.
2301 if (tline
&& tline
->next
) {
2302 def
->dlist
= tline
->next
;
2304 count_mmac_params(def
->dlist
, &def
->ndefs
, &def
->defaults
);
2307 def
->defaults
= NULL
;
2311 if (def
->defaults
&& def
->ndefs
> def
->nparam_max
- def
->nparam_min
&&
2313 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MDP
,
2314 "too many default macro parameters");
2321 * Decode a size directive
2323 static int parse_size(const char *str
) {
2324 static const char *size_names
[] =
2325 { "byte", "dword", "oword", "qword", "tword", "word", "yword" };
2326 static const int sizes
[] =
2327 { 0, 1, 4, 16, 8, 10, 2, 32 };
2329 return sizes
[bsii(str
, size_names
, ARRAY_SIZE(size_names
))+1];
2333 * find and process preprocessor directive in passed line
2334 * Find out if a line contains a preprocessor directive, and deal
2337 * If a directive _is_ found, it is the responsibility of this routine
2338 * (and not the caller) to free_tlist() the line.
2340 * @param tline a pointer to the current tokeninzed line linked list
2341 * @return DIRECTIVE_FOUND or NO_DIRECTIVE_FOUND
2344 static int do_directive(Token
* tline
)
2346 enum preproc_token i
;
2359 Token
*t
, *tt
, *param_start
, *macro_start
, *last
, **tptr
, *origline
;
2360 struct tokenval tokval
;
2362 ExpDef
*ed
, *eed
, **edhead
;
2371 if (!tline
|| !tok_type_(tline
, TOK_PREPROC_ID
) ||
2372 (tline
->text
[1] == '%' || tline
->text
[1] == '$'
2373 || tline
->text
[1] == '!'))
2374 return NO_DIRECTIVE_FOUND
;
2376 i
= pp_token_hash(tline
->text
);
2380 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2381 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
2383 return NO_DIRECTIVE_FOUND
; /* didn't get it */
2386 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2387 /* Directive to tell NASM what the default stack size is. The
2388 * default is for a 16-bit stack, and this can be overriden with
2391 tline
= tline
->next
;
2392 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2393 tline
= tline
->next
;
2394 if (!tline
|| tline
->type
!= TOK_ID
) {
2395 error(ERR_NONFATAL
, "`%%stacksize' missing size parameter");
2396 free_tlist(origline
);
2397 return DIRECTIVE_FOUND
;
2399 if (nasm_stricmp(tline
->text
, "flat") == 0) {
2400 /* All subsequent ARG directives are for a 32-bit stack */
2402 StackPointer
= "ebp";
2405 } else if (nasm_stricmp(tline
->text
, "flat64") == 0) {
2406 /* All subsequent ARG directives are for a 64-bit stack */
2408 StackPointer
= "rbp";
2411 } else if (nasm_stricmp(tline
->text
, "large") == 0) {
2412 /* All subsequent ARG directives are for a 16-bit stack,
2413 * far function call.
2416 StackPointer
= "bp";
2419 } else if (nasm_stricmp(tline
->text
, "small") == 0) {
2420 /* All subsequent ARG directives are for a 16-bit stack,
2421 * far function call. We don't support near functions.
2424 StackPointer
= "bp";
2428 error(ERR_NONFATAL
, "`%%stacksize' invalid size type");
2429 free_tlist(origline
);
2430 return DIRECTIVE_FOUND
;
2432 free_tlist(origline
);
2433 return DIRECTIVE_FOUND
;
2436 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2437 /* TASM like ARG directive to define arguments to functions, in
2438 * the following form:
2440 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
2444 char *arg
, directive
[256];
2445 int size
= StackSize
;
2447 /* Find the argument name */
2448 tline
= tline
->next
;
2449 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2450 tline
= tline
->next
;
2451 if (!tline
|| tline
->type
!= TOK_ID
) {
2452 error(ERR_NONFATAL
, "`%%arg' missing argument parameter");
2453 free_tlist(origline
);
2454 return DIRECTIVE_FOUND
;
2458 /* Find the argument size type */
2459 tline
= tline
->next
;
2460 if (!tline
|| tline
->type
!= TOK_OTHER
2461 || tline
->text
[0] != ':') {
2463 "Syntax error processing `%%arg' directive");
2464 free_tlist(origline
);
2465 return DIRECTIVE_FOUND
;
2467 tline
= tline
->next
;
2468 if (!tline
|| tline
->type
!= TOK_ID
) {
2469 error(ERR_NONFATAL
, "`%%arg' missing size type parameter");
2470 free_tlist(origline
);
2471 return DIRECTIVE_FOUND
;
2474 /* Allow macro expansion of type parameter */
2475 tt
= tokenize(tline
->text
);
2476 tt
= expand_smacro(tt
);
2477 size
= parse_size(tt
->text
);
2480 "Invalid size type for `%%arg' missing directive");
2482 free_tlist(origline
);
2483 return DIRECTIVE_FOUND
;
2487 /* Round up to even stack slots */
2488 size
= ALIGN(size
, StackSize
);
2490 /* Now define the macro for the argument */
2491 snprintf(directive
, sizeof(directive
), "%%define %s (%s+%d)",
2492 arg
, StackPointer
, offset
);
2493 do_directive(tokenize(directive
));
2496 /* Move to the next argument in the list */
2497 tline
= tline
->next
;
2498 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2499 tline
= tline
->next
;
2500 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2502 free_tlist(origline
);
2503 return DIRECTIVE_FOUND
;
2506 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2507 /* TASM like LOCAL directive to define local variables for a
2508 * function, in the following form:
2510 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
2512 * The '= LocalSize' at the end is ignored by NASM, but is
2513 * required by TASM to define the local parameter size (and used
2514 * by the TASM macro package).
2516 offset
= LocalOffset
;
2518 char *local
, directive
[256];
2519 int size
= StackSize
;
2521 /* Find the argument name */
2522 tline
= tline
->next
;
2523 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2524 tline
= tline
->next
;
2525 if (!tline
|| tline
->type
!= TOK_ID
) {
2527 "`%%local' missing argument parameter");
2528 free_tlist(origline
);
2529 return DIRECTIVE_FOUND
;
2531 local
= tline
->text
;
2533 /* Find the argument size type */
2534 tline
= tline
->next
;
2535 if (!tline
|| tline
->type
!= TOK_OTHER
2536 || tline
->text
[0] != ':') {
2538 "Syntax error processing `%%local' directive");
2539 free_tlist(origline
);
2540 return DIRECTIVE_FOUND
;
2542 tline
= tline
->next
;
2543 if (!tline
|| tline
->type
!= TOK_ID
) {
2545 "`%%local' missing size type parameter");
2546 free_tlist(origline
);
2547 return DIRECTIVE_FOUND
;
2550 /* Allow macro expansion of type parameter */
2551 tt
= tokenize(tline
->text
);
2552 tt
= expand_smacro(tt
);
2553 size
= parse_size(tt
->text
);
2556 "Invalid size type for `%%local' missing directive");
2558 free_tlist(origline
);
2559 return DIRECTIVE_FOUND
;
2563 /* Round up to even stack slots */
2564 size
= ALIGN(size
, StackSize
);
2566 offset
+= size
; /* Negative offset, increment before */
2568 /* Now define the macro for the argument */
2569 snprintf(directive
, sizeof(directive
), "%%define %s (%s-%d)",
2570 local
, StackPointer
, offset
);
2571 do_directive(tokenize(directive
));
2573 /* Now define the assign to setup the enter_c macro correctly */
2574 snprintf(directive
, sizeof(directive
),
2575 "%%assign %%$localsize %%$localsize+%d", size
);
2576 do_directive(tokenize(directive
));
2578 /* Move to the next argument in the list */
2579 tline
= tline
->next
;
2580 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2581 tline
= tline
->next
;
2582 } while (tline
&& tline
->type
== TOK_OTHER
&& tline
->text
[0] == ',');
2583 LocalOffset
= offset
;
2584 free_tlist(origline
);
2585 return DIRECTIVE_FOUND
;
2588 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2590 error(ERR_WARNING
|ERR_PASS1
,
2591 "trailing garbage after `%%clear' ignored");
2594 free_tlist(origline
);
2595 return DIRECTIVE_FOUND
;
2598 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2599 t
= tline
->next
= expand_smacro(tline
->next
);
2601 if (!t
|| (t
->type
!= TOK_STRING
&&
2602 t
->type
!= TOK_INTERNAL_STRING
)) {
2603 error(ERR_NONFATAL
, "`%%depend' expects a file name");
2604 free_tlist(origline
);
2605 return DIRECTIVE_FOUND
; /* but we did _something_ */
2608 error(ERR_WARNING
|ERR_PASS1
,
2609 "trailing garbage after `%%depend' ignored");
2611 if (t
->type
!= TOK_INTERNAL_STRING
)
2612 nasm_unquote_cstr(p
, i
);
2613 if (dephead
&& !in_list(*dephead
, p
)) {
2614 StrList
*sl
= nasm_malloc(strlen(p
)+1+sizeof sl
->next
);
2618 deptail
= &sl
->next
;
2620 free_tlist(origline
);
2621 return DIRECTIVE_FOUND
;
2624 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2625 t
= tline
->next
= expand_smacro(tline
->next
);
2628 if (!t
|| (t
->type
!= TOK_STRING
&&
2629 t
->type
!= TOK_INTERNAL_STRING
)) {
2630 error(ERR_NONFATAL
, "`%%include' expects a file name");
2631 free_tlist(origline
);
2632 return DIRECTIVE_FOUND
; /* but we did _something_ */
2635 error(ERR_WARNING
|ERR_PASS1
,
2636 "trailing garbage after `%%include' ignored");
2638 if (t
->type
!= TOK_INTERNAL_STRING
)
2639 nasm_unquote_cstr(p
, i
);
2640 inc
= nasm_zalloc(sizeof(Include
));
2642 inc
->fp
= inc_fopen(p
, dephead
, &deptail
, pass
== 0);
2644 /* -MG given but file not found */
2647 inc
->fname
= src_set_fname(nasm_strdup(p
));
2648 inc
->lineno
= src_set_linnum(0);
2650 inc
->expansion
= NULL
;
2652 list
->uplevel(LIST_INCLUDE
);
2654 free_tlist(origline
);
2655 return DIRECTIVE_FOUND
;
2658 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2660 static macros_t
*use_pkg
;
2661 const char *pkg_macro
= NULL
;
2663 tline
= tline
->next
;
2665 tline
= expand_id(tline
);
2667 if (!tline
|| (tline
->type
!= TOK_STRING
&&
2668 tline
->type
!= TOK_INTERNAL_STRING
&&
2669 tline
->type
!= TOK_ID
)) {
2670 error(ERR_NONFATAL
, "`%%use' expects a package name");
2671 free_tlist(origline
);
2672 return DIRECTIVE_FOUND
; /* but we did _something_ */
2675 error(ERR_WARNING
|ERR_PASS1
,
2676 "trailing garbage after `%%use' ignored");
2677 if (tline
->type
== TOK_STRING
)
2678 nasm_unquote_cstr(tline
->text
, i
);
2679 use_pkg
= nasm_stdmac_find_package(tline
->text
);
2681 error(ERR_NONFATAL
, "unknown `%%use' package: %s", tline
->text
);
2683 pkg_macro
= (char *)use_pkg
+ 1; /* The first string will be <%define>__USE_*__ */
2684 if (use_pkg
&& ! smacro_defined(NULL
, pkg_macro
, 0, NULL
, true)) {
2685 /* Not already included, go ahead and include it */
2686 stdmacpos
= use_pkg
;
2688 free_tlist(origline
);
2689 return DIRECTIVE_FOUND
;
2694 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2695 tline
= tline
->next
;
2697 tline
= expand_id(tline
);
2699 if (!tok_type_(tline
, TOK_ID
)) {
2700 error(ERR_NONFATAL
, "`%s' expects a context identifier",
2702 free_tlist(origline
);
2703 return DIRECTIVE_FOUND
; /* but we did _something_ */
2706 error(ERR_WARNING
|ERR_PASS1
,
2707 "trailing garbage after `%s' ignored",
2709 p
= nasm_strdup(tline
->text
);
2711 p
= NULL
; /* Anonymous */
2715 ctx
= nasm_zalloc(sizeof(Context
));
2717 hash_init(&ctx
->localmac
, HASH_SMALL
);
2719 ctx
->number
= unique
++;
2724 error(ERR_NONFATAL
, "`%s': context stack is empty",
2726 } else if (i
== PP_POP
) {
2727 if (p
&& (!cstk
->name
|| nasm_stricmp(p
, cstk
->name
)))
2728 error(ERR_NONFATAL
, "`%%pop' in wrong context: %s, "
2730 cstk
->name
? cstk
->name
: "anonymous", p
);
2735 nasm_free(cstk
->name
);
2741 free_tlist(origline
);
2742 return DIRECTIVE_FOUND
;
2744 severity
= ERR_FATAL
;
2747 severity
= ERR_NONFATAL
;
2750 severity
= ERR_WARNING
|ERR_WARN_USER
;
2754 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2756 /* Only error out if this is the final pass */
2757 if (pass
!= 2 && i
!= PP_FATAL
)
2758 return DIRECTIVE_FOUND
;
2760 tline
->next
= expand_smacro(tline
->next
);
2761 tline
= tline
->next
;
2763 t
= tline
? tline
->next
: NULL
;
2765 if (tok_type_(tline
, TOK_STRING
) && !t
) {
2766 /* The line contains only a quoted string */
2768 nasm_unquote(p
, NULL
); /* Ignore NUL character truncation */
2769 error(severity
, "%s", p
);
2771 /* Not a quoted string, or more than a quoted string */
2772 p
= detoken(tline
, false);
2773 error(severity
, "%s", p
);
2776 free_tlist(origline
);
2777 return DIRECTIVE_FOUND
;
2781 if (defining
!= NULL
) {
2782 if (defining
->type
== EXP_IF
) {
2783 defining
->def_depth
++;
2785 return NO_DIRECTIVE_FOUND
;
2787 if ((istk
->expansion
!= NULL
) &&
2788 (istk
->expansion
->emitting
== false)) {
2791 j
= if_condition(tline
->next
, i
);
2792 tline
->next
= NULL
; /* it got freed */
2793 j
= (((j
< 0) ? COND_NEVER
: j
) ? COND_IF_TRUE
: COND_IF_FALSE
);
2795 ed
= new_ExpDef(EXP_IF
);
2797 ed
->ignoring
= ((ed
->state
== COND_IF_TRUE
) ? false : true);
2798 ed
->prev
= defining
;
2800 free_tlist(origline
);
2801 return DIRECTIVE_FOUND
;
2804 if (defining
!= NULL
) {
2805 if ((defining
->type
!= EXP_IF
) || (defining
->def_depth
> 0)) {
2806 return NO_DIRECTIVE_FOUND
;
2809 if ((defining
== NULL
) || (defining
->type
!= EXP_IF
)) {
2810 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2812 switch (defining
->state
) {
2814 defining
->state
= COND_DONE
;
2815 defining
->ignoring
= true;
2820 defining
->ignoring
= true;
2823 case COND_ELSE_TRUE
:
2824 case COND_ELSE_FALSE
:
2825 error_precond(ERR_WARNING
|ERR_PASS1
,
2826 "`%%elif' after `%%else' ignored");
2827 defining
->state
= COND_NEVER
;
2828 defining
->ignoring
= true;
2833 * IMPORTANT: In the case of %if, we will already have
2834 * called expand_mmac_params(); however, if we're
2835 * processing an %elif we must have been in a
2836 * non-emitting mode, which would have inhibited
2837 * the normal invocation of expand_mmac_params().
2838 * Therefore, we have to do it explicitly here.
2840 j
= if_condition(expand_mmac_params(tline
->next
), i
);
2841 tline
->next
= NULL
; /* it got freed */
2843 j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2844 defining
->ignoring
= ((defining
->state
== COND_IF_TRUE
) ? false : true);
2847 free_tlist(origline
);
2848 return DIRECTIVE_FOUND
;
2851 if (defining
!= NULL
) {
2852 if ((defining
->type
!= EXP_IF
) || (defining
->def_depth
> 0)) {
2853 return NO_DIRECTIVE_FOUND
;
2857 error_precond(ERR_WARNING
|ERR_PASS1
,
2858 "trailing garbage after `%%else' ignored");
2859 if ((defining
== NULL
) || (defining
->type
!= EXP_IF
)) {
2860 error(ERR_FATAL
, "`%s': no matching `%%if'", pp_directives
[i
]);
2862 switch (defining
->state
) {
2865 defining
->state
= COND_ELSE_FALSE
;
2866 defining
->ignoring
= true;
2870 defining
->ignoring
= true;
2874 defining
->state
= COND_ELSE_TRUE
;
2875 defining
->ignoring
= false;
2878 case COND_ELSE_TRUE
:
2879 case COND_ELSE_FALSE
:
2880 error_precond(ERR_WARNING
|ERR_PASS1
,
2881 "`%%else' after `%%else' ignored.");
2882 defining
->state
= COND_NEVER
;
2883 defining
->ignoring
= true;
2886 free_tlist(origline
);
2887 return DIRECTIVE_FOUND
;
2890 if (defining
!= NULL
) {
2891 if (defining
->type
== EXP_IF
) {
2892 if (defining
->def_depth
> 0) {
2893 defining
->def_depth
--;
2894 return NO_DIRECTIVE_FOUND
;
2897 return NO_DIRECTIVE_FOUND
;
2901 error_precond(ERR_WARNING
|ERR_PASS1
,
2902 "trailing garbage after `%%endif' ignored");
2903 if ((defining
== NULL
) || (defining
->type
!= EXP_IF
)) {
2904 error(ERR_NONFATAL
, "`%%endif': no matching `%%if'");
2905 return DIRECTIVE_FOUND
;
2908 defining
= ed
->prev
;
2909 ed
->prev
= expansions
;
2911 ei
= new_ExpInv(EXP_IF
, ed
);
2912 ei
->current
= ed
->line
;
2913 ei
->emitting
= true;
2914 ei
->prev
= istk
->expansion
;
2915 istk
->expansion
= ei
;
2916 free_tlist(origline
);
2917 return DIRECTIVE_FOUND
;
2923 if (defining
!= NULL
) {
2924 if (defining
->type
== EXP_MMACRO
) {
2925 defining
->def_depth
++;
2927 return NO_DIRECTIVE_FOUND
;
2929 ed
= new_ExpDef(EXP_MMACRO
);
2931 (i
== PP_RMACRO
) || (i
== PP_IRMACRO
) ? DEADMAN_LIMIT
: 0;
2932 ed
->casesense
= (i
== PP_MACRO
) || (i
== PP_RMACRO
);
2933 if (!parse_mmacro_spec(tline
, ed
, pp_directives
[i
])) {
2936 return DIRECTIVE_FOUND
;
2940 ed
->max_depth
= (ed
->max_depth
+ 1);
2941 ed
->ignoring
= false;
2942 ed
->prev
= defining
;
2945 eed
= (ExpDef
*) hash_findix(&expdefs
, ed
->name
);
2947 if (!strcmp(eed
->name
, ed
->name
) &&
2948 (eed
->nparam_min
<= ed
->nparam_max
|| ed
->plus
) &&
2949 (ed
->nparam_min
<= eed
->nparam_max
|| eed
->plus
)) {
2950 error(ERR_WARNING
|ERR_PASS1
,
2951 "redefining multi-line macro `%s'", ed
->name
);
2952 return DIRECTIVE_FOUND
;
2956 free_tlist(origline
);
2957 return DIRECTIVE_FOUND
;
2961 if (defining
!= NULL
) {
2962 if (defining
->type
== EXP_MMACRO
) {
2963 if (defining
->def_depth
> 0) {
2964 defining
->def_depth
--;
2965 return NO_DIRECTIVE_FOUND
;
2968 return NO_DIRECTIVE_FOUND
;
2971 if (!(defining
) || (defining
->type
!= EXP_MMACRO
)) {
2972 error(ERR_NONFATAL
, "`%s': not defining a macro", tline
->text
);
2973 return DIRECTIVE_FOUND
;
2975 edhead
= (ExpDef
**) hash_findi_add(&expdefs
, defining
->name
);
2976 defining
->next
= *edhead
;
2979 defining
= ed
->prev
;
2980 ed
->prev
= expansions
;
2983 free_tlist(origline
);
2984 return DIRECTIVE_FOUND
;
2987 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
2989 * We must search along istk->expansion until we hit a
2990 * macro invocation. Then we disable the emitting state(s)
2991 * between exitmacro and endmacro.
2993 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
2994 if(ei
->type
== EXP_MMACRO
) {
3001 * Set all invocations leading back to the macro
3002 * invocation to a non-emitting state.
3004 for (eei
= istk
->expansion
; eei
!= ei
; eei
= eei
->prev
) {
3005 eei
->emitting
= false;
3007 eei
->emitting
= false;
3009 error(ERR_NONFATAL
, "`%%exitmacro' not within `%%macro' block");
3011 free_tlist(origline
);
3012 return DIRECTIVE_FOUND
;
3016 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3021 spec
.casesense
= (i
== PP_UNMACRO
);
3022 if (!parse_mmacro_spec(tline
, &spec
, pp_directives
[i
])) {
3023 return DIRECTIVE_FOUND
;
3025 ed_p
= (ExpDef
**) hash_findi(&expdefs
, spec
.name
, NULL
);
3026 while (ed_p
&& *ed_p
) {
3028 if (ed
->casesense
== spec
.casesense
&&
3029 !mstrcmp(ed
->name
, spec
.name
, spec
.casesense
) &&
3030 ed
->nparam_min
== spec
.nparam_min
&&
3031 ed
->nparam_max
== spec
.nparam_max
&&
3032 ed
->plus
== spec
.plus
) {
3033 if (ed
->cur_depth
> 0) {
3034 error(ERR_NONFATAL
, "`%s' ignored on active macro",
3045 free_tlist(origline
);
3046 free_tlist(spec
.dlist
);
3047 return DIRECTIVE_FOUND
;
3051 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3052 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
3053 tline
= tline
->next
;
3055 free_tlist(origline
);
3056 error(ERR_NONFATAL
, "`%%rotate' missing rotate count");
3057 return DIRECTIVE_FOUND
;
3059 t
= expand_smacro(tline
->next
);
3061 free_tlist(origline
);
3064 tokval
.t_type
= TOKEN_INVALID
;
3066 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3069 return DIRECTIVE_FOUND
;
3071 error(ERR_WARNING
|ERR_PASS1
,
3072 "trailing garbage after expression ignored");
3073 if (!is_simple(evalresult
)) {
3074 error(ERR_NONFATAL
, "non-constant value given to `%%rotate'");
3075 return DIRECTIVE_FOUND
;
3077 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
3078 if (ei
->type
== EXP_MMACRO
) {
3083 error(ERR_NONFATAL
, "`%%rotate' invoked outside a macro call");
3084 } else if (ei
->nparam
== 0) {
3086 "`%%rotate' invoked within macro without parameters");
3088 int rotate
= ei
->rotate
+ reloc_value(evalresult
);
3090 rotate
%= (int)ei
->nparam
;
3092 rotate
+= ei
->nparam
;
3093 ei
->rotate
= rotate
;
3095 return DIRECTIVE_FOUND
;
3098 if (defining
!= NULL
) {
3099 if (defining
->type
== EXP_REP
) {
3100 defining
->def_depth
++;
3102 return NO_DIRECTIVE_FOUND
;
3106 tline
= tline
->next
;
3107 } while (tok_type_(tline
, TOK_WHITESPACE
));
3109 if (tok_type_(tline
, TOK_ID
) &&
3110 nasm_stricmp(tline
->text
, ".nolist") == 0) {
3113 tline
= tline
->next
;
3114 } while (tok_type_(tline
, TOK_WHITESPACE
));
3118 t
= expand_smacro(tline
);
3120 tokval
.t_type
= TOKEN_INVALID
;
3122 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3124 free_tlist(origline
);
3125 return DIRECTIVE_FOUND
;
3128 error(ERR_WARNING
|ERR_PASS1
,
3129 "trailing garbage after expression ignored");
3130 if (!is_simple(evalresult
)) {
3131 error(ERR_NONFATAL
, "non-constant value given to `%%rep'");
3132 return DIRECTIVE_FOUND
;
3134 count
= reloc_value(evalresult
);
3135 if (count
>= REP_LIMIT
) {
3136 error(ERR_NONFATAL
, "`%%rep' value exceeds limit");
3141 error(ERR_NONFATAL
, "`%%rep' expects a repeat count");
3144 free_tlist(origline
);
3145 ed
= new_ExpDef(EXP_REP
);
3146 ed
->nolist
= nolist
;
3149 ed
->max_depth
= (count
- 1);
3150 ed
->ignoring
= false;
3151 ed
->prev
= defining
;
3153 return DIRECTIVE_FOUND
;
3156 if (defining
!= NULL
) {
3157 if (defining
->type
== EXP_REP
) {
3158 if (defining
->def_depth
> 0) {
3159 defining
->def_depth
--;
3160 return NO_DIRECTIVE_FOUND
;
3163 return NO_DIRECTIVE_FOUND
;
3166 if ((defining
== NULL
) || (defining
->type
!= EXP_REP
)) {
3167 error(ERR_NONFATAL
, "`%%endrep': no matching `%%rep'");
3168 return DIRECTIVE_FOUND
;
3172 * Now we have a "macro" defined - although it has no name
3173 * and we won't be entering it in the hash tables - we must
3174 * push a macro-end marker for it on to istk->expansion.
3175 * After that, it will take care of propagating itself (a
3176 * macro-end marker line for a macro which is really a %rep
3177 * block will cause the macro to be re-expanded, complete
3178 * with another macro-end marker to ensure the process
3179 * continues) until the whole expansion is forcibly removed
3180 * from istk->expansion by a %exitrep.
3183 defining
= ed
->prev
;
3184 ed
->prev
= expansions
;
3186 ei
= new_ExpInv(EXP_REP
, ed
);
3187 ei
->current
= ed
->line
;
3188 ei
->emitting
= ((ed
->max_depth
> 0) ? true : false);
3189 list
->uplevel(ed
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
3190 ei
->prev
= istk
->expansion
;
3191 istk
->expansion
= ei
;
3192 free_tlist(origline
);
3193 return DIRECTIVE_FOUND
;
3196 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3198 * We must search along istk->expansion until we hit a
3199 * rep invocation. Then we disable the emitting state(s)
3200 * between exitrep and endrep.
3202 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
3203 if (ei
->type
== EXP_REP
) {
3210 * Set all invocations leading back to the rep
3211 * invocation to a non-emitting state.
3213 for (eei
= istk
->expansion
; eei
!= ei
; eei
= eei
->prev
) {
3214 eei
->emitting
= false;
3216 eei
->emitting
= false;
3217 eei
->current
= NULL
;
3218 eei
->def
->cur_depth
= eei
->def
->max_depth
;
3220 error(ERR_NONFATAL
, "`%%exitrep' not within `%%rep' block");
3222 free_tlist(origline
);
3223 return DIRECTIVE_FOUND
;
3229 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3230 casesense
= (i
== PP_DEFINE
|| i
== PP_XDEFINE
);
3232 tline
= tline
->next
;
3234 tline
= expand_id(tline
);
3235 if (!tline
|| (tline
->type
!= TOK_ID
&&
3236 (tline
->type
!= TOK_PREPROC_ID
||
3237 tline
->text
[1] != '$'))) {
3238 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
3240 free_tlist(origline
);
3241 return DIRECTIVE_FOUND
;
3244 ctx
= get_ctx(tline
->text
, &mname
);
3246 param_start
= tline
= tline
->next
;
3249 /* Expand the macro definition now for %xdefine and %ixdefine */
3250 if ((i
== PP_XDEFINE
) || (i
== PP_IXDEFINE
))
3251 tline
= expand_smacro(tline
);
3253 if (tok_is_(tline
, "(")) {
3255 * This macro has parameters.
3258 tline
= tline
->next
;
3262 error(ERR_NONFATAL
, "parameter identifier expected");
3263 free_tlist(origline
);
3264 return DIRECTIVE_FOUND
;
3266 if (tline
->type
!= TOK_ID
) {
3268 "`%s': parameter identifier expected",
3270 free_tlist(origline
);
3271 return DIRECTIVE_FOUND
;
3274 smacro_set_param_idx(tline
, nparam
);
3277 tline
= tline
->next
;
3279 if (tok_is_(tline
, ",")) {
3280 tline
= tline
->next
;
3282 if (!tok_is_(tline
, ")")) {
3284 "`)' expected to terminate macro template");
3285 free_tlist(origline
);
3286 return DIRECTIVE_FOUND
;
3292 tline
= tline
->next
;
3294 if (tok_type_(tline
, TOK_WHITESPACE
))
3295 last
= tline
, tline
= tline
->next
;
3300 if (t
->type
== TOK_ID
) {
3301 list_for_each(tt
, param_start
)
3302 if (is_smacro_param(tt
) &&
3303 !strcmp(tt
->text
, t
->text
))
3307 t
->next
= macro_start
;
3312 * Good. We now have a macro name, a parameter count, and a
3313 * token list (in reverse order) for an expansion. We ought
3314 * to be OK just to create an SMacro, store it, and let
3315 * free_tlist have the rest of the line (which we have
3316 * carefully re-terminated after chopping off the expansion
3319 define_smacro(ctx
, mname
, casesense
, nparam
, macro_start
);
3320 free_tlist(origline
);
3321 return DIRECTIVE_FOUND
;
3324 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3325 tline
= tline
->next
;
3327 tline
= expand_id(tline
);
3328 if (!tline
|| (tline
->type
!= TOK_ID
&&
3329 (tline
->type
!= TOK_PREPROC_ID
||
3330 tline
->text
[1] != '$'))) {
3331 error(ERR_NONFATAL
, "`%%undef' expects a macro identifier");
3332 free_tlist(origline
);
3333 return DIRECTIVE_FOUND
;
3336 error(ERR_WARNING
|ERR_PASS1
,
3337 "trailing garbage after macro name ignored");
3340 /* Find the context that symbol belongs to */
3341 ctx
= get_ctx(tline
->text
, &mname
);
3342 undef_smacro(ctx
, mname
);
3343 free_tlist(origline
);
3344 return DIRECTIVE_FOUND
;
3348 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3349 casesense
= (i
== PP_DEFSTR
);
3351 tline
= tline
->next
;
3353 tline
= expand_id(tline
);
3354 if (!tline
|| (tline
->type
!= TOK_ID
&&
3355 (tline
->type
!= TOK_PREPROC_ID
||
3356 tline
->text
[1] != '$'))) {
3357 error(ERR_NONFATAL
, "`%s' expects a macro identifier",
3359 free_tlist(origline
);
3360 return DIRECTIVE_FOUND
;
3363 ctx
= get_ctx(tline
->text
, &mname
);
3365 tline
= expand_smacro(tline
->next
);
3368 while (tok_type_(tline
, TOK_WHITESPACE
))
3369 tline
= delete_Token(tline
);
3371 p
= detoken(tline
, false);
3372 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3373 macro_start
->text
= nasm_quote(p
, strlen(p
));
3374 macro_start
->type
= TOK_STRING
;
3378 * We now have a macro name, an implicit parameter count of
3379 * zero, and a string token to use as an expansion. Create
3380 * and store an SMacro.
3382 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3383 free_tlist(origline
);
3384 return DIRECTIVE_FOUND
;
3388 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3389 casesense
= (i
== PP_DEFTOK
);
3391 tline
= tline
->next
;
3393 tline
= expand_id(tline
);
3394 if (!tline
|| (tline
->type
!= TOK_ID
&&
3395 (tline
->type
!= TOK_PREPROC_ID
||
3396 tline
->text
[1] != '$'))) {
3398 "`%s' expects a macro identifier as first parameter",
3400 free_tlist(origline
);
3401 return DIRECTIVE_FOUND
;
3403 ctx
= get_ctx(tline
->text
, &mname
);
3405 tline
= expand_smacro(tline
->next
);
3409 while (tok_type_(t
, TOK_WHITESPACE
))
3411 /* t should now point to the string */
3412 if (!tok_type_(t
, TOK_STRING
)) {
3414 "`%s` requires string as second parameter",
3417 free_tlist(origline
);
3418 return DIRECTIVE_FOUND
;
3422 * Convert the string to a token stream. Note that smacros
3423 * are stored with the token stream reversed, so we have to
3424 * reverse the output of tokenize().
3426 nasm_unquote_cstr(t
->text
, i
);
3427 macro_start
= reverse_tokens(tokenize(t
->text
));
3430 * We now have a macro name, an implicit parameter count of
3431 * zero, and a numeric token to use as an expansion. Create
3432 * and store an SMacro.
3434 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3436 free_tlist(origline
);
3437 return DIRECTIVE_FOUND
;
3440 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3443 StrList
*xsl
= NULL
;
3444 StrList
**xst
= &xsl
;
3448 tline
= tline
->next
;
3450 tline
= expand_id(tline
);
3451 if (!tline
|| (tline
->type
!= TOK_ID
&&
3452 (tline
->type
!= TOK_PREPROC_ID
||
3453 tline
->text
[1] != '$'))) {
3455 "`%%pathsearch' expects a macro identifier as first parameter");
3456 free_tlist(origline
);
3457 return DIRECTIVE_FOUND
;
3459 ctx
= get_ctx(tline
->text
, &mname
);
3461 tline
= expand_smacro(tline
->next
);
3465 while (tok_type_(t
, TOK_WHITESPACE
))
3468 if (!t
|| (t
->type
!= TOK_STRING
&&
3469 t
->type
!= TOK_INTERNAL_STRING
)) {
3470 error(ERR_NONFATAL
, "`%%pathsearch' expects a file name");
3472 free_tlist(origline
);
3473 return DIRECTIVE_FOUND
; /* but we did _something_ */
3476 error(ERR_WARNING
|ERR_PASS1
,
3477 "trailing garbage after `%%pathsearch' ignored");
3479 if (t
->type
!= TOK_INTERNAL_STRING
)
3480 nasm_unquote(p
, NULL
);
3482 fp
= inc_fopen(p
, &xsl
, &xst
, true);
3485 fclose(fp
); /* Don't actually care about the file */
3487 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3488 macro_start
->text
= nasm_quote(p
, strlen(p
));
3489 macro_start
->type
= TOK_STRING
;
3493 * We now have a macro name, an implicit parameter count of
3494 * zero, and a string token to use as an expansion. Create
3495 * and store an SMacro.
3497 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3499 free_tlist(origline
);
3500 return DIRECTIVE_FOUND
;
3504 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3507 tline
= tline
->next
;
3509 tline
= expand_id(tline
);
3510 if (!tline
|| (tline
->type
!= TOK_ID
&&
3511 (tline
->type
!= TOK_PREPROC_ID
||
3512 tline
->text
[1] != '$'))) {
3514 "`%%strlen' expects a macro identifier as first parameter");
3515 free_tlist(origline
);
3516 return DIRECTIVE_FOUND
;
3518 ctx
= get_ctx(tline
->text
, &mname
);
3520 tline
= expand_smacro(tline
->next
);
3524 while (tok_type_(t
, TOK_WHITESPACE
))
3526 /* t should now point to the string */
3527 if (!tok_type_(t
, TOK_STRING
)) {
3529 "`%%strlen` requires string as second parameter");
3531 free_tlist(origline
);
3532 return DIRECTIVE_FOUND
;
3535 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3536 make_tok_num(macro_start
, nasm_unquote(t
->text
, NULL
));
3539 * We now have a macro name, an implicit parameter count of
3540 * zero, and a numeric token to use as an expansion. Create
3541 * and store an SMacro.
3543 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3545 free_tlist(origline
);
3546 return DIRECTIVE_FOUND
;
3549 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3552 tline
= tline
->next
;
3554 tline
= expand_id(tline
);
3555 if (!tline
|| (tline
->type
!= TOK_ID
&&
3556 (tline
->type
!= TOK_PREPROC_ID
||
3557 tline
->text
[1] != '$'))) {
3559 "`%%strcat' expects a macro identifier as first parameter");
3560 free_tlist(origline
);
3561 return DIRECTIVE_FOUND
;
3563 ctx
= get_ctx(tline
->text
, &mname
);
3565 tline
= expand_smacro(tline
->next
);
3569 list_for_each(t
, tline
) {
3571 case TOK_WHITESPACE
:
3574 len
+= t
->a
.len
= nasm_unquote(t
->text
, NULL
);
3577 if (!strcmp(t
->text
, ",")) /* permit comma separators */
3579 /* else fall through */
3582 "non-string passed to `%%strcat' (%d)", t
->type
);
3584 free_tlist(origline
);
3585 return DIRECTIVE_FOUND
;
3589 p
= pp
= nasm_malloc(len
);
3590 list_for_each(t
, tline
) {
3591 if (t
->type
== TOK_STRING
) {
3592 memcpy(p
, t
->text
, t
->a
.len
);
3598 * We now have a macro name, an implicit parameter count of
3599 * zero, and a numeric token to use as an expansion. Create
3600 * and store an SMacro.
3602 macro_start
= new_Token(NULL
, TOK_STRING
, NULL
, 0);
3603 macro_start
->text
= nasm_quote(pp
, len
);
3605 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3607 free_tlist(origline
);
3608 return DIRECTIVE_FOUND
;
3611 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3613 int64_t start
, count
;
3618 tline
= tline
->next
;
3620 tline
= expand_id(tline
);
3621 if (!tline
|| (tline
->type
!= TOK_ID
&&
3622 (tline
->type
!= TOK_PREPROC_ID
||
3623 tline
->text
[1] != '$'))) {
3625 "`%%substr' expects a macro identifier as first parameter");
3626 free_tlist(origline
);
3627 return DIRECTIVE_FOUND
;
3629 ctx
= get_ctx(tline
->text
, &mname
);
3631 tline
= expand_smacro(tline
->next
);
3634 if (tline
) /* skip expanded id */
3636 while (tok_type_(t
, TOK_WHITESPACE
))
3639 /* t should now point to the string */
3640 if (!tok_type_(t
, TOK_STRING
)) {
3642 "`%%substr` requires string as second parameter");
3644 free_tlist(origline
);
3645 return DIRECTIVE_FOUND
;
3650 tokval
.t_type
= TOKEN_INVALID
;
3651 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3655 free_tlist(origline
);
3656 return DIRECTIVE_FOUND
;
3657 } else if (!is_simple(evalresult
)) {
3658 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3660 free_tlist(origline
);
3661 return DIRECTIVE_FOUND
;
3663 start
= evalresult
->value
- 1;
3665 while (tok_type_(tt
, TOK_WHITESPACE
))
3668 count
= 1; /* Backwards compatibility: one character */
3670 tokval
.t_type
= TOKEN_INVALID
;
3671 evalresult
= evaluate(ppscan
, tptr
, &tokval
, NULL
,
3675 free_tlist(origline
);
3676 return DIRECTIVE_FOUND
;
3677 } else if (!is_simple(evalresult
)) {
3678 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
3680 free_tlist(origline
);
3681 return DIRECTIVE_FOUND
;
3683 count
= evalresult
->value
;
3686 len
= nasm_unquote(t
->text
, NULL
);
3687 /* make start and count being in range */
3691 count
= len
+ count
+ 1 - start
;
3692 if (start
+ count
> (int64_t)len
)
3693 count
= len
- start
;
3694 if (!len
|| count
< 0 || start
>=(int64_t)len
)
3695 start
= -1, count
= 0; /* empty string */
3697 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3698 macro_start
->text
= nasm_quote((start
< 0) ? "" : t
->text
+ start
, count
);
3699 macro_start
->type
= TOK_STRING
;
3702 * We now have a macro name, an implicit parameter count of
3703 * zero, and a numeric token to use as an expansion. Create
3704 * and store an SMacro.
3706 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3708 free_tlist(origline
);
3709 return DIRECTIVE_FOUND
;
3714 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3715 casesense
= (i
== PP_ASSIGN
);
3717 tline
= tline
->next
;
3719 tline
= expand_id(tline
);
3720 if (!tline
|| (tline
->type
!= TOK_ID
&&
3721 (tline
->type
!= TOK_PREPROC_ID
||
3722 tline
->text
[1] != '$'))) {
3724 "`%%%sassign' expects a macro identifier",
3725 (i
== PP_IASSIGN
? "i" : ""));
3726 free_tlist(origline
);
3727 return DIRECTIVE_FOUND
;
3729 ctx
= get_ctx(tline
->text
, &mname
);
3731 tline
= expand_smacro(tline
->next
);
3736 tokval
.t_type
= TOKEN_INVALID
;
3738 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
3741 free_tlist(origline
);
3742 return DIRECTIVE_FOUND
;
3746 error(ERR_WARNING
|ERR_PASS1
,
3747 "trailing garbage after expression ignored");
3749 if (!is_simple(evalresult
)) {
3751 "non-constant value given to `%%%sassign'",
3752 (i
== PP_IASSIGN
? "i" : ""));
3753 free_tlist(origline
);
3754 return DIRECTIVE_FOUND
;
3757 macro_start
= nasm_zalloc(sizeof(*macro_start
));
3758 make_tok_num(macro_start
, reloc_value(evalresult
));
3761 * We now have a macro name, an implicit parameter count of
3762 * zero, and a numeric token to use as an expansion. Create
3763 * and store an SMacro.
3765 define_smacro(ctx
, mname
, casesense
, 0, macro_start
);
3766 free_tlist(origline
);
3767 return DIRECTIVE_FOUND
;
3770 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3772 * Syntax is `%line nnn[+mmm] [filename]'
3774 tline
= tline
->next
;
3776 if (!tok_type_(tline
, TOK_NUMBER
)) {
3777 error(ERR_NONFATAL
, "`%%line' expects line number");
3778 free_tlist(origline
);
3779 return DIRECTIVE_FOUND
;
3781 k
= readnum(tline
->text
, &err
);
3783 tline
= tline
->next
;
3784 if (tok_is_(tline
, "+")) {
3785 tline
= tline
->next
;
3786 if (!tok_type_(tline
, TOK_NUMBER
)) {
3787 error(ERR_NONFATAL
, "`%%line' expects line increment");
3788 free_tlist(origline
);
3789 return DIRECTIVE_FOUND
;
3791 m
= readnum(tline
->text
, &err
);
3792 tline
= tline
->next
;
3798 nasm_free(src_set_fname(detoken(tline
, false)));
3800 free_tlist(origline
);
3801 return DIRECTIVE_FOUND
;
3804 if (defining
!= NULL
) {
3805 if (defining
->type
== EXP_WHILE
) {
3806 defining
->def_depth
++;
3808 return NO_DIRECTIVE_FOUND
;
3811 if ((istk
->expansion
!= NULL
) &&
3812 (istk
->expansion
->emitting
== false)) {
3816 l
->first
= copy_Token(tline
->next
);
3817 j
= if_condition(tline
->next
, i
);
3818 tline
->next
= NULL
; /* it got freed */
3819 j
= (((j
< 0) ? COND_NEVER
: j
) ? COND_IF_TRUE
: COND_IF_FALSE
);
3821 ed
= new_ExpDef(EXP_WHILE
);
3824 ed
->max_depth
= DEADMAN_LIMIT
;
3825 ed
->ignoring
= ((ed
->state
== COND_IF_TRUE
) ? false : true);
3826 if (ed
->ignoring
== false) {
3829 } else if (l
!= NULL
) {
3830 delete_Token(l
->first
);
3834 ed
->prev
= defining
;
3836 free_tlist(origline
);
3837 return DIRECTIVE_FOUND
;
3840 if (defining
!= NULL
) {
3841 if (defining
->type
== EXP_WHILE
) {
3842 if (defining
->def_depth
> 0) {
3843 defining
->def_depth
--;
3844 return NO_DIRECTIVE_FOUND
;
3847 return NO_DIRECTIVE_FOUND
;
3850 if (tline
->next
!= NULL
) {
3851 error_precond(ERR_WARNING
|ERR_PASS1
,
3852 "trailing garbage after `%%endwhile' ignored");
3854 if ((defining
== NULL
) || (defining
->type
!= EXP_WHILE
)) {
3855 error(ERR_NONFATAL
, "`%%endwhile': no matching `%%while'");
3856 return DIRECTIVE_FOUND
;
3859 defining
= ed
->prev
;
3860 if (ed
->ignoring
== false) {
3861 ed
->prev
= expansions
;
3863 ei
= new_ExpInv(EXP_WHILE
, ed
);
3864 ei
->current
= ed
->line
->next
;
3865 ei
->emitting
= true;
3866 ei
->prev
= istk
->expansion
;
3867 istk
->expansion
= ei
;
3871 free_tlist(origline
);
3872 return DIRECTIVE_FOUND
;
3875 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3877 * We must search along istk->expansion until we hit a
3878 * while invocation. Then we disable the emitting state(s)
3879 * between exitwhile and endwhile.
3881 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
3882 if (ei
->type
== EXP_WHILE
) {
3889 * Set all invocations leading back to the while
3890 * invocation to a non-emitting state.
3892 for (eei
= istk
->expansion
; eei
!= ei
; eei
= eei
->prev
) {
3893 eei
->emitting
= false;
3895 eei
->emitting
= false;
3896 eei
->current
= NULL
;
3897 eei
->def
->cur_depth
= eei
->def
->max_depth
;
3899 error(ERR_NONFATAL
, "`%%exitwhile' not within `%%while' block");
3901 free_tlist(origline
);
3902 return DIRECTIVE_FOUND
;
3905 if (defining
!= NULL
) {
3906 if (defining
->type
== EXP_COMMENT
) {
3907 defining
->def_depth
++;
3909 return NO_DIRECTIVE_FOUND
;
3911 ed
= new_ExpDef(EXP_COMMENT
);
3912 ed
->ignoring
= true;
3913 ed
->prev
= defining
;
3915 free_tlist(origline
);
3916 return DIRECTIVE_FOUND
;
3919 if (defining
!= NULL
) {
3920 if (defining
->type
== EXP_COMMENT
) {
3921 if (defining
->def_depth
> 0) {
3922 defining
->def_depth
--;
3923 return NO_DIRECTIVE_FOUND
;
3926 return NO_DIRECTIVE_FOUND
;
3929 if ((defining
== NULL
) || (defining
->type
!= EXP_COMMENT
)) {
3930 error(ERR_NONFATAL
, "`%%endcomment': no matching `%%comment'");
3931 return DIRECTIVE_FOUND
;
3934 defining
= ed
->prev
;
3936 free_tlist(origline
);
3937 return DIRECTIVE_FOUND
;
3940 if (defining
!= NULL
) return NO_DIRECTIVE_FOUND
;
3941 if (in_final
!= false) {
3942 error(ERR_FATAL
, "`%%final' cannot be used recursively");
3944 tline
= tline
->next
;
3946 if (tline
== NULL
) {
3947 error(ERR_NONFATAL
, "`%%final' expects at least one parameter");
3950 l
->first
= copy_Token(tline
);
3954 free_tlist(origline
);
3955 return DIRECTIVE_FOUND
;
3959 "preprocessor directive `%s' not yet implemented",
3961 return DIRECTIVE_FOUND
;
3966 * Ensure that a macro parameter contains a condition code and
3967 * nothing else. Return the condition code index if so, or -1
3970 static int find_cc(Token
* t
)
3976 return -1; /* Probably a %+ without a space */
3979 if (t
->type
!= TOK_ID
)
3983 if (tt
&& (tt
->type
!= TOK_OTHER
|| strcmp(tt
->text
, ",")))
3987 j
= ARRAY_SIZE(conditions
);
3990 m
= nasm_stricmp(t
->text
, conditions
[k
]);
4005 static bool paste_tokens(Token
**head
, const struct tokseq_match
*m
,
4006 int mnum
, bool handle_paste_tokens
)
4008 Token
**tail
, *t
, *tt
;
4010 bool did_paste
= false;
4014 /* Now handle token pasting... */
4017 while ((t
= *tail
) && (tt
= t
->next
)) {
4019 case TOK_WHITESPACE
:
4020 if (tt
->type
== TOK_WHITESPACE
) {
4021 /* Zap adjacent whitespace tokens */
4022 t
->next
= delete_Token(tt
);
4024 /* Do not advance paste_head here */
4028 case TOK_PASTE
: /* %+ */
4029 if (handle_paste_tokens
) {
4030 /* Zap %+ and whitespace tokens to the right */
4031 while (t
&& (t
->type
== TOK_WHITESPACE
||
4032 t
->type
== TOK_PASTE
))
4033 t
= *tail
= delete_Token(t
);
4034 if (!paste_head
|| !t
)
4035 break; /* Nothing to paste with */
4039 while (tok_type_(tt
, TOK_WHITESPACE
))
4040 tt
= t
->next
= delete_Token(tt
);
4042 tmp
= nasm_strcat(t
->text
, tt
->text
);
4044 tt
= delete_Token(tt
);
4045 t
= *tail
= tokenize(tmp
);
4051 t
->next
= tt
; /* Attach the remaining token chain */
4058 /* else fall through */
4061 * Concatenation of tokens might look nontrivial
4062 * but in real it's pretty simple -- the caller
4063 * prepares the masks of token types to be concatenated
4064 * and we simply find matched sequences and slip
4067 for (i
= 0; i
< mnum
; i
++) {
4068 if (PP_CONCAT_MASK(t
->type
) & m
[i
].mask_head
) {
4072 while (tt
&& (PP_CONCAT_MASK(tt
->type
) & m
[i
].mask_tail
)) {
4073 len
+= strlen(tt
->text
);
4077 nasm_dump_token(tt
);
4080 * Now tt points to the first token after
4081 * the potential paste area...
4083 if (tt
!= t
->next
) {
4084 /* We have at least two tokens... */
4085 len
+= strlen(t
->text
);
4086 p
= tmp
= nasm_malloc(len
+1);
4089 p
= strchr(p
, '\0');
4090 t
= delete_Token(t
);
4092 t
= *tail
= tokenize(tmp
);
4098 t
->next
= tt
; /* Attach the remaining token chain */
4106 if (i
>= mnum
) { /* no match */
4108 if (!tok_type_(t
->next
, TOK_WHITESPACE
))
4118 * expands to a list of tokens from %{x:y}
4120 static Token
*expand_mmac_params_range(ExpInv
*ei
, Token
*tline
, Token
***last
)
4122 Token
*t
= tline
, **tt
, *tm
, *head
;
4126 pos
= strchr(tline
->text
, ':');
4129 lst
= atoi(pos
+ 1);
4130 fst
= atoi(tline
->text
+ 1);
4133 * only macros params are accounted so
4134 * if someone passes %0 -- we reject such
4137 if (lst
== 0 || fst
== 0)
4140 /* the values should be sane */
4141 if ((fst
> (int)ei
->nparam
|| fst
< (-(int)ei
->nparam
)) ||
4142 (lst
> (int)ei
->nparam
|| lst
< (-(int)ei
->nparam
)))
4145 fst
= fst
< 0 ? fst
+ (int)ei
->nparam
+ 1: fst
;
4146 lst
= lst
< 0 ? lst
+ (int)ei
->nparam
+ 1: lst
;
4148 /* counted from zero */
4152 * it will be at least one token
4154 tm
= ei
->params
[(fst
+ ei
->rotate
) % ei
->nparam
];
4155 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
4156 head
= t
, tt
= &t
->next
;
4158 for (i
= fst
+ 1; i
<= lst
; i
++) {
4159 t
= new_Token(NULL
, TOK_OTHER
, ",", 0);
4160 *tt
= t
, tt
= &t
->next
;
4161 j
= (i
+ ei
->rotate
) % ei
->nparam
;
4163 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
4164 *tt
= t
, tt
= &t
->next
;
4167 for (i
= fst
- 1; i
>= lst
; i
--) {
4168 t
= new_Token(NULL
, TOK_OTHER
, ",", 0);
4169 *tt
= t
, tt
= &t
->next
;
4170 j
= (i
+ ei
->rotate
) % ei
->nparam
;
4172 t
= new_Token(NULL
, tm
->type
, tm
->text
, 0);
4173 *tt
= t
, tt
= &t
->next
;
4181 error(ERR_NONFATAL
, "`%%{%s}': macro parameters out of range",
4187 * Expand MMacro-local things: parameter references (%0, %n, %+n,
4188 * %-n) and MMacro-local identifiers (%%foo) as well as
4189 * macro indirection (%[...]) and range (%{..:..}).
4191 static Token
*expand_mmac_params(Token
* tline
)
4193 Token
*t
, *tt
, **tail
, *thead
;
4194 bool changed
= false;
4200 nasm_dump_stream(tline
);
4203 if (tline
->type
== TOK_PREPROC_ID
&&
4204 (((tline
->text
[1] == '+' || tline
->text
[1] == '-') && tline
->text
[2]) ||
4205 (tline
->text
[1] >= '0' && tline
->text
[1] <= '9') ||
4206 tline
->text
[1] == '%')) {
4208 int type
= 0, cc
; /* type = 0 to placate optimisers */
4215 tline
= tline
->next
;
4217 for (ei
= istk
->expansion
; ei
!= NULL
; ei
= ei
->prev
) {
4218 if (ei
->type
== EXP_MMACRO
) {
4223 error(ERR_NONFATAL
, "`%s': not in a macro call", t
->text
);
4225 pos
= strchr(t
->text
, ':');
4227 switch (t
->text
[1]) {
4229 * We have to make a substitution of one of the
4230 * forms %1, %-1, %+1, %%foo, %0.
4233 if ((strlen(t
->text
) > 2) && (t
->text
[2] == '0')) {
4235 text
= nasm_strdup(ei
->label_text
);
4238 snprintf(tmpbuf
, sizeof(tmpbuf
), "%d", ei
->nparam
);
4239 text
= nasm_strdup(tmpbuf
);
4244 snprintf(tmpbuf
, sizeof(tmpbuf
), "..@%"PRIu64
".",
4246 text
= nasm_strcat(tmpbuf
, t
->text
+ 2);
4249 n
= atoi(t
->text
+ 2) - 1;
4250 if (n
>= ei
->nparam
)
4254 n
= (n
+ ei
->rotate
) % ei
->nparam
;
4260 "macro parameter %d is not a condition code",
4265 if (inverse_ccs
[cc
] == -1) {
4267 "condition code `%s' is not invertible",
4271 text
= nasm_strdup(conditions
[inverse_ccs
[cc
]]);
4275 n
= atoi(t
->text
+ 2) - 1;
4276 if (n
>= ei
->nparam
)
4280 n
= (n
+ ei
->rotate
) % ei
->nparam
;
4286 "macro parameter %d is not a condition code",
4291 text
= nasm_strdup(conditions
[cc
]);
4295 n
= atoi(t
->text
+ 1) - 1;
4296 if (n
>= ei
->nparam
)
4300 n
= (n
+ ei
->rotate
) % ei
->nparam
;
4304 for (i
= 0; i
< ei
->paramlen
[n
]; i
++) {
4305 *tail
= new_Token(NULL
, tt
->type
, tt
->text
, 0);
4306 tail
= &(*tail
)->next
;
4310 text
= NULL
; /* we've done it here */
4315 * seems we have a parameters range here
4317 Token
*head
, **last
;
4318 head
= expand_mmac_params_range(ei
, t
, &last
);
4339 } else if (tline
->type
== TOK_INDIRECT
) {
4341 tline
= tline
->next
;
4342 tt
= tokenize(t
->text
);
4343 tt
= expand_mmac_params(tt
);
4344 tt
= expand_smacro(tt
);
4347 tt
->a
.mac
= NULL
; /* Necessary? */
4355 tline
= tline
->next
;
4363 const struct tokseq_match t
[] = {
4365 PP_CONCAT_MASK(TOK_ID
) |
4366 PP_CONCAT_MASK(TOK_FLOAT
), /* head */
4367 PP_CONCAT_MASK(TOK_ID
) |
4368 PP_CONCAT_MASK(TOK_NUMBER
) |
4369 PP_CONCAT_MASK(TOK_FLOAT
) |
4370 PP_CONCAT_MASK(TOK_OTHER
) /* tail */
4373 PP_CONCAT_MASK(TOK_NUMBER
), /* head */
4374 PP_CONCAT_MASK(TOK_NUMBER
) /* tail */
4377 paste_tokens(&thead
, t
, ARRAY_SIZE(t
), false);
4380 nasm_dump_token(thead
);
4386 * Expand all single-line macro calls made in the given line.
4387 * Return the expanded version of the line. The original is deemed
4388 * to be destroyed in the process. (In reality we'll just move
4389 * Tokens from input to output a lot of the time, rather than
4390 * actually bothering to destroy and replicate.)
4393 static Token
*expand_smacro(Token
* tline
)
4395 Token
*t
, *tt
, *mstart
, **tail
, *thead
;
4396 SMacro
*head
= NULL
, *m
;
4399 unsigned int nparam
, sparam
;
4401 Token
*org_tline
= tline
;
4404 int deadman
= DEADMAN_LIMIT
;
4408 * Trick: we should avoid changing the start token pointer since it can
4409 * be contained in "next" field of other token. Because of this
4410 * we allocate a copy of first token and work with it; at the end of
4411 * routine we copy it back
4414 tline
= new_Token(org_tline
->next
, org_tline
->type
,
4415 org_tline
->text
, 0);
4416 tline
->a
.mac
= org_tline
->a
.mac
;
4417 nasm_free(org_tline
->text
);
4418 org_tline
->text
= NULL
;
4421 expanded
= true; /* Always expand %+ at least once */
4427 while (tline
) { /* main token loop */
4429 error(ERR_NONFATAL
, "interminable macro recursion");
4433 if ((mname
= tline
->text
)) {
4434 /* if this token is a local macro, look in local context */
4435 if (tline
->type
== TOK_ID
) {
4436 head
= (SMacro
*)hash_findix(&smacros
, mname
);
4437 } else if (tline
->type
== TOK_PREPROC_ID
) {
4438 ctx
= get_ctx(mname
, &mname
);
4439 head
= ctx
? (SMacro
*)hash_findix(&ctx
->localmac
, mname
) : NULL
;
4444 * We've hit an identifier. As in is_mmacro below, we first
4445 * check whether the identifier is a single-line macro at
4446 * all, then think about checking for parameters if
4449 list_for_each(m
, head
)
4450 if (!mstrcmp(m
->name
, mname
, m
->casesense
))
4456 if (m
->nparam
== 0) {
4458 * Simple case: the macro is parameterless. Discard the
4459 * one token that the macro call took, and push the
4460 * expansion back on the to-do stack.
4462 if (!m
->expansion
) {
4463 if (!strcmp("__FILE__", m
->name
)) {
4466 src_get(&num
, &file
);
4467 tline
->text
= nasm_quote(file
, strlen(file
));
4468 tline
->type
= TOK_STRING
;
4472 if (!strcmp("__LINE__", m
->name
)) {
4473 nasm_free(tline
->text
);
4474 make_tok_num(tline
, src_get_linnum());
4477 if (!strcmp("__BITS__", m
->name
)) {
4478 nasm_free(tline
->text
);
4479 make_tok_num(tline
, globalbits
);
4482 tline
= delete_Token(tline
);
4487 * Complicated case: at least one macro with this name
4488 * exists and takes parameters. We must find the
4489 * parameters in the call, count them, find the SMacro
4490 * that corresponds to that form of the macro call, and
4491 * substitute for the parameters when we expand. What a
4494 /*tline = tline->next;
4495 skip_white_(tline); */
4498 while (tok_type_(t
, TOK_SMAC_END
)) {
4499 t
->a
.mac
->in_progress
= false;
4501 t
= tline
->next
= delete_Token(t
);
4504 } while (tok_type_(tline
, TOK_WHITESPACE
));
4505 if (!tok_is_(tline
, "(")) {
4507 * This macro wasn't called with parameters: ignore
4508 * the call. (Behaviour borrowed from gnu cpp.)
4517 sparam
= PARAM_DELTA
;
4518 params
= nasm_malloc(sparam
* sizeof(Token
*));
4519 params
[0] = tline
->next
;
4520 paramsize
= nasm_malloc(sparam
* sizeof(int));
4522 while (true) { /* parameter loop */
4524 * For some unusual expansions
4525 * which concatenates function call
4528 while (tok_type_(t
, TOK_SMAC_END
)) {
4529 t
->a
.mac
->in_progress
= false;
4531 t
= tline
->next
= delete_Token(t
);
4537 "macro call expects terminating `)'");
4540 if (tline
->type
== TOK_WHITESPACE
4542 if (paramsize
[nparam
])
4545 params
[nparam
] = tline
->next
;
4546 continue; /* parameter loop */
4548 if (tline
->type
== TOK_OTHER
4549 && tline
->text
[1] == 0) {
4550 char ch
= tline
->text
[0];
4551 if (ch
== ',' && !paren
&& brackets
<= 0) {
4552 if (++nparam
>= sparam
) {
4553 sparam
+= PARAM_DELTA
;
4554 params
= nasm_realloc(params
,
4555 sparam
* sizeof(Token
*));
4556 paramsize
= nasm_realloc(paramsize
,
4557 sparam
* sizeof(int));
4559 params
[nparam
] = tline
->next
;
4560 paramsize
[nparam
] = 0;
4562 continue; /* parameter loop */
4565 (brackets
> 0 || (brackets
== 0 &&
4566 !paramsize
[nparam
])))
4568 if (!(brackets
++)) {
4569 params
[nparam
] = tline
->next
;
4570 continue; /* parameter loop */
4573 if (ch
== '}' && brackets
> 0)
4574 if (--brackets
== 0) {
4576 continue; /* parameter loop */
4578 if (ch
== '(' && !brackets
)
4580 if (ch
== ')' && brackets
<= 0)
4586 error(ERR_NONFATAL
, "braces do not "
4587 "enclose all of macro parameter");
4589 paramsize
[nparam
] += white
+ 1;
4591 } /* parameter loop */
4593 while (m
&& (m
->nparam
!= nparam
||
4594 mstrcmp(m
->name
, mname
,
4598 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MNP
,
4599 "macro `%s' exists, "
4600 "but not taking %d parameters",
4601 mstart
->text
, nparam
);
4604 if (m
&& m
->in_progress
)
4606 if (!m
) { /* in progess or didn't find '(' or wrong nparam */
4608 * Design question: should we handle !tline, which
4609 * indicates missing ')' here, or expand those
4610 * macros anyway, which requires the (t) test a few
4614 nasm_free(paramsize
);
4618 * Expand the macro: we are placed on the last token of the
4619 * call, so that we can easily split the call from the
4620 * following tokens. We also start by pushing an SMAC_END
4621 * token for the cycle removal.
4628 tt
= new_Token(tline
, TOK_SMAC_END
, NULL
, 0);
4630 m
->in_progress
= true;
4632 list_for_each(t
, m
->expansion
) {
4633 if (is_smacro_param(t
)) {
4634 Token
*pcopy
= tline
, **ptail
= &pcopy
;
4638 idx
= smacro_get_param_idx(t
);
4642 * We need smacro paramters appended.
4644 for (i
= paramsize
[idx
]; i
> 0; i
--) {
4645 *ptail
= new_Token(tline
, ttt
->type
, ttt
->text
, 0);
4646 ptail
= &(*ptail
)->next
;
4651 } else if (t
->type
== TOK_PREPROC_Q
) {
4652 tt
= new_Token(tline
, TOK_ID
, mname
, 0);
4654 } else if (t
->type
== TOK_PREPROC_QQ
) {
4655 tt
= new_Token(tline
, TOK_ID
, m
->name
, 0);
4658 tt
= new_Token(tline
, t
->type
, t
->text
, 0);
4664 * Having done that, get rid of the macro call, and clean
4665 * up the parameters.
4668 nasm_free(paramsize
);
4671 continue; /* main token loop */
4676 if (tline
->type
== TOK_SMAC_END
) {
4677 tline
->a
.mac
->in_progress
= false;
4678 tline
= delete_Token(tline
);
4681 tline
= tline
->next
;
4689 * Now scan the entire line and look for successive TOK_IDs that resulted
4690 * after expansion (they can't be produced by tokenize()). The successive
4691 * TOK_IDs should be concatenated.
4692 * Also we look for %+ tokens and concatenate the tokens before and after
4693 * them (without white spaces in between).
4696 const struct tokseq_match t
[] = {
4698 PP_CONCAT_MASK(TOK_ID
) |
4699 PP_CONCAT_MASK(TOK_PREPROC_ID
), /* head */
4700 PP_CONCAT_MASK(TOK_ID
) |
4701 PP_CONCAT_MASK(TOK_PREPROC_ID
) |
4702 PP_CONCAT_MASK(TOK_NUMBER
) /* tail */
4705 if (paste_tokens(&thead
, t
, ARRAY_SIZE(t
), true)) {
4707 * If we concatenated something, *and* we had previously expanded
4708 * an actual macro, scan the lines again for macros...
4719 *org_tline
= *thead
;
4720 /* since we just gave text to org_line, don't free it */
4722 delete_Token(thead
);
4724 /* the expression expanded to empty line;
4725 we can't return NULL for some reasons
4726 we just set the line to a single WHITESPACE token. */
4727 memset(org_tline
, 0, sizeof(*org_tline
));
4728 org_tline
->text
= NULL
;
4729 org_tline
->type
= TOK_WHITESPACE
;
4738 * Similar to expand_smacro but used exclusively with macro identifiers
4739 * right before they are fetched in. The reason is that there can be
4740 * identifiers consisting of several subparts. We consider that if there
4741 * are more than one element forming the name, user wants a expansion,
4742 * otherwise it will be left as-is. Example:
4746 * the identifier %$abc will be left as-is so that the handler for %define
4747 * will suck it and define the corresponding value. Other case:
4749 * %define _%$abc cde
4751 * In this case user wants name to be expanded *before* %define starts
4752 * working, so we'll expand %$abc into something (if it has a value;
4753 * otherwise it will be left as-is) then concatenate all successive
4756 static Token
*expand_id(Token
* tline
)
4758 Token
*cur
, *oldnext
= NULL
;
4760 if (!tline
|| !tline
->next
)
4765 (cur
->next
->type
== TOK_ID
||
4766 cur
->next
->type
== TOK_PREPROC_ID
||
4767 cur
->next
->type
== TOK_NUMBER
))
4770 /* If identifier consists of just one token, don't expand */
4775 oldnext
= cur
->next
; /* Detach the tail past identifier */
4776 cur
->next
= NULL
; /* so that expand_smacro stops here */
4779 tline
= expand_smacro(tline
);
4782 /* expand_smacro possibly changhed tline; re-scan for EOL */
4784 while (cur
&& cur
->next
)
4787 cur
->next
= oldnext
;
4794 * Determine whether the given line constitutes a multi-line macro
4795 * call, and return the ExpDef structure called if so. Doesn't have
4796 * to check for an initial label - that's taken care of in
4797 * expand_mmacro - but must check numbers of parameters. Guaranteed
4798 * to be called with tline->type == TOK_ID, so the putative macro
4799 * name is easy to find.
4801 static ExpDef
*is_mmacro(Token
* tline
, Token
*** params_array
)
4807 head
= (ExpDef
*) hash_findix(&expdefs
, tline
->text
);
4810 * Efficiency: first we see if any macro exists with the given
4811 * name. If not, we can return NULL immediately. _Then_ we
4812 * count the parameters, and then we look further along the
4813 * list if necessary to find the proper ExpDef.
4815 list_for_each(ed
, head
)
4816 if (!mstrcmp(ed
->name
, tline
->text
, ed
->casesense
))
4822 * OK, we have a potential macro. Count and demarcate the
4825 count_mmac_params(tline
->next
, &nparam
, ¶ms
);
4828 * So we know how many parameters we've got. Find the ExpDef
4829 * structure that handles this number.
4832 if (ed
->nparam_min
<= nparam
4833 && (ed
->plus
|| nparam
<= ed
->nparam_max
)) {
4835 * It's right, and we can use it. Add its default
4836 * parameters to the end of our list if necessary.
4838 if (ed
->defaults
&& nparam
< ed
->nparam_min
+ ed
->ndefs
) {
4840 nasm_realloc(params
,
4841 ((ed
->nparam_min
+ ed
->ndefs
+
4842 1) * sizeof(*params
)));
4843 while (nparam
< ed
->nparam_min
+ ed
->ndefs
) {
4844 params
[nparam
] = ed
->defaults
[nparam
- ed
->nparam_min
];
4849 * If we've gone over the maximum parameter count (and
4850 * we're in Plus mode), ignore parameters beyond
4853 if (ed
->plus
&& nparam
> ed
->nparam_max
)
4854 nparam
= ed
->nparam_max
;
4856 * Then terminate the parameter list, and leave.
4858 if (!params
) { /* need this special case */
4859 params
= nasm_malloc(sizeof(*params
));
4862 params
[nparam
] = NULL
;
4863 *params_array
= params
;
4867 * This one wasn't right: look for the next one with the
4870 list_for_each(ed
, ed
->next
)
4871 if (!mstrcmp(ed
->name
, tline
->text
, ed
->casesense
))
4876 * After all that, we didn't find one with the right number of
4877 * parameters. Issue a warning, and fail to expand the macro.
4879 error(ERR_WARNING
|ERR_PASS1
|ERR_WARN_MNP
,
4880 "macro `%s' exists, but not taking %d parameters",
4881 tline
->text
, nparam
);
4887 * Expand the multi-line macro call made by the given line, if
4888 * there is one to be expanded. If there is, push the expansion on
4889 * istk->expansion and return true. Otherwise return false.
4891 static bool expand_mmacro(Token
* tline
)
4893 Token
*label
= NULL
;
4894 int dont_prepend
= 0;
4899 int i
, nparam
, *paramlen
;
4904 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
4905 if (!tok_type_(t
, TOK_ID
) && !tok_type_(t
, TOK_PREPROC_ID
))
4907 ed
= is_mmacro(t
, ¶ms
);
4913 * We have an id which isn't a macro call. We'll assume
4914 * it might be a label; we'll also check to see if a
4915 * colon follows it. Then, if there's another id after
4916 * that lot, we'll check it again for macro-hood.
4920 if (tok_type_(t
, TOK_WHITESPACE
))
4921 last
= t
, t
= t
->next
;
4922 if (tok_is_(t
, ":")) {
4924 last
= t
, t
= t
->next
;
4925 if (tok_type_(t
, TOK_WHITESPACE
))
4926 last
= t
, t
= t
->next
;
4928 if (!tok_type_(t
, TOK_ID
) || !(ed
= is_mmacro(t
, ¶ms
)))
4936 * Fix up the parameters: this involves stripping leading and
4937 * trailing whitespace, then stripping braces if they are
4940 for (nparam
= 0; params
[nparam
]; nparam
++) ;
4941 paramlen
= nparam
? nasm_malloc(nparam
* sizeof(*paramlen
)) : NULL
;
4943 for (i
= 0; params
[i
]; i
++) {
4945 int comma
= (!ed
->plus
|| i
< nparam
- 1);
4949 if (tok_is_(t
, "{"))
4950 t
= t
->next
, brace
= true, comma
= false;
4954 if (comma
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, ","))
4955 break; /* ... because we have hit a comma */
4956 if (comma
&& t
->type
== TOK_WHITESPACE
4957 && tok_is_(t
->next
, ","))
4958 break; /* ... or a space then a comma */
4959 if (brace
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, "}"))
4960 break; /* ... or a brace */
4966 if (ed
->cur_depth
>= ed
->max_depth
) {
4967 if (ed
->max_depth
> 1) {
4969 "reached maximum macro recursion depth of %i for %s",
4970 ed
->max_depth
,ed
->name
);
4978 * OK, we have found a ExpDef structure representing a
4979 * previously defined mmacro. Create an expansion invocation
4980 * and point it back to the expansion definition. Substitution of
4981 * parameter tokens and macro-local tokens doesn't get done
4982 * until the single-line macro substitution process; this is
4983 * because delaying them allows us to change the semantics
4984 * later through %rotate.
4986 ei
= new_ExpInv(EXP_MMACRO
, ed
);
4987 ei
->name
= nasm_strdup(mname
);
4988 //ei->label = label;
4989 //ei->label_text = detoken(label, false);
4990 ei
->current
= ed
->line
;
4991 ei
->emitting
= true;
4992 //ei->iline = tline;
4993 ei
->params
= params
;
4994 ei
->nparam
= nparam
;
4996 ei
->paramlen
= paramlen
;
4999 ei
->prev
= istk
->expansion
;
5000 istk
->expansion
= ei
;
5003 * Special case: detect %00 on first invocation; if found,
5004 * avoid emitting any labels that precede the mmacro call.
5005 * ed->prepend is set to -1 when %00 is detected, else 1.
5007 if (ed
->prepend
== 0) {
5008 for (l
= ed
->line
; l
!= NULL
; l
= l
->next
) {
5009 for (t
= l
->first
; t
!= NULL
; t
= t
->next
) {
5010 if ((t
->type
== TOK_PREPROC_ID
) &&
5011 (strlen(t
->text
) == 3) &&
5012 (t
->text
[1] == '0') && (t
->text
[2] == '0')) {
5017 if (dont_prepend
< 0) {
5021 ed
->prepend
= ((dont_prepend
< 0) ? -1 : 1);
5025 * If we had a label, push it on as the first line of
5026 * the macro expansion.
5028 if (label
!= NULL
) {
5029 if (ed
->prepend
< 0) {
5030 ei
->label_text
= detoken(label
, false);
5032 if (dont_prepend
== 0) {
5034 while (t
->next
!= NULL
) {
5037 t
->next
= new_Token(NULL
, TOK_OTHER
, ":", 0);
5040 l
->first
= copy_Token(label
);
5041 l
->next
= ei
->current
;
5046 list
->uplevel(ed
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
5052 /* The function that actually does the error reporting */
5053 static void verror(int severity
, const char *fmt
, va_list arg
)
5057 vsnprintf(buff
, sizeof(buff
), fmt
, arg
);
5059 if (istk
&& istk
->mmac_depth
> 0) {
5060 ExpInv
*ei
= istk
->expansion
;
5061 int lineno
= ei
->lineno
;
5063 if (ei
->type
== EXP_MMACRO
)
5065 lineno
+= ei
->relno
;
5068 nasm_error(severity
, "(%s:%d) %s", ei
->def
->name
,
5071 nasm_error(severity
, "%s", buff
);
5075 * Since preprocessor always operate only on the line that didn't
5076 * arrived yet, we should always use ERR_OFFBY1.
5078 static void error(int severity
, const char *fmt
, ...)
5082 verror(severity
, fmt
, arg
);
5087 * Because %else etc are evaluated in the state context
5088 * of the previous branch, errors might get lost with error():
5089 * %if 0 ... %else trailing garbage ... %endif
5090 * So %else etc should report errors with this function.
5092 static void error_precond(int severity
, const char *fmt
, ...)
5096 /* Only ignore the error if it's really in a dead branch */
5097 if ((istk
!= NULL
) &&
5098 (istk
->expansion
!= NULL
) &&
5099 (istk
->expansion
->type
== EXP_IF
) &&
5100 (istk
->expansion
->def
->state
== COND_NEVER
))
5104 verror(severity
, fmt
, arg
);
5109 pp_reset(char *file
, int apass
, ListGen
* listgen
, StrList
**deplist
)
5114 istk
= nasm_zalloc(sizeof(Include
));
5115 istk
->fp
= fopen(file
, "r");
5116 src_set_fname(nasm_strdup(file
));
5120 error(ERR_FATAL
|ERR_NOFILE
, "unable to open input file `%s'",
5125 nested_mac_count
= 0;
5126 nested_rep_count
= 0;
5129 if (tasm_compatible_mode
) {
5130 stdmacpos
= nasm_stdmac
;
5132 stdmacpos
= nasm_stdmac_after_tasm
;
5134 any_extrastdmac
= extrastdmac
&& *extrastdmac
;
5139 * 0 for dependencies, 1 for preparatory passes, 2 for final pass.
5140 * The caller, however, will also pass in 3 for preprocess-only so
5141 * we can set __PASS__ accordingly.
5143 pass
= apass
> 2 ? 2 : apass
;
5145 dephead
= deptail
= deplist
;
5147 StrList
*sl
= nasm_malloc(strlen(file
)+1+sizeof sl
->next
);
5149 strcpy(sl
->str
, file
);
5151 deptail
= &sl
->next
;
5155 * Define the __PASS__ macro. This is defined here unlike
5156 * all the other builtins, because it is special -- it varies between
5159 t
= nasm_zalloc(sizeof(*t
));
5160 make_tok_num(t
, apass
);
5161 define_smacro(NULL
, "__PASS__", true, 0, t
);
5164 static char *pp_getline(void)
5175 * Fetch a tokenized line, either from the expansion
5176 * buffer or from the input file.
5180 while (1) { /* until we get a line we can use */
5182 * Fetch a tokenized line from the expansion buffer
5184 if (istk
->expansion
!= NULL
) {
5185 ei
= istk
->expansion
;
5186 if (ei
->current
!= NULL
) {
5187 if (ei
->emitting
== false) {
5192 ei
->current
= l
->next
;
5194 tline
= copy_Token(l
->first
);
5195 if (((ei
->type
== EXP_REP
) ||
5196 (ei
->type
== EXP_MMACRO
) ||
5197 (ei
->type
== EXP_WHILE
))
5198 && (ei
->def
->nolist
== false)) {
5199 char *p
= detoken(tline
, false);
5200 list
->line(LIST_MACRO
, p
);
5203 if (ei
->linnum
> -1) {
5204 src_set_linnum(src_get_linnum() + 1);
5207 } else if ((ei
->type
== EXP_REP
) &&
5208 (ei
->def
->cur_depth
< ei
->def
->max_depth
)) {
5209 ei
->def
->cur_depth
++;
5210 ei
->current
= ei
->def
->line
;
5213 } else if ((ei
->type
== EXP_WHILE
) &&
5214 (ei
->def
->cur_depth
< ei
->def
->max_depth
)) {
5215 ei
->current
= ei
->def
->line
;
5217 tline
= copy_Token(ei
->current
->first
);
5218 j
= if_condition(tline
, PP_WHILE
);
5220 j
= (((j
< 0) ? COND_NEVER
: j
) ? COND_IF_TRUE
: COND_IF_FALSE
);
5221 if (j
== COND_IF_TRUE
) {
5222 ei
->current
= ei
->current
->next
;
5223 ei
->def
->cur_depth
++;
5225 ei
->emitting
= false;
5227 ei
->def
->cur_depth
= ei
->def
->max_depth
;
5231 istk
->expansion
= ei
->prev
;
5234 if ((ei
->emitting
== true) &&
5235 (ed
->max_depth
== DEADMAN_LIMIT
) &&
5236 (ed
->cur_depth
== DEADMAN_LIMIT
)
5238 error(ERR_FATAL
, "runaway expansion detected, aborting");
5240 if (ed
->cur_depth
> 0) {
5242 } else if (ed
->type
!= EXP_MMACRO
) {
5243 expansions
= ed
->prev
;
5246 if ((ei
->type
== EXP_REP
) ||
5247 (ei
->type
== EXP_MMACRO
) ||
5248 (ei
->type
== EXP_WHILE
)) {
5249 list
->downlevel(LIST_MACRO
);
5250 if (ei
->type
== EXP_MMACRO
) {
5255 if (ei
->linnum
> -1) {
5256 src_set_linnum(ei
->linnum
);
5264 * Read in line from input and tokenize
5267 if (line
) { /* from the current input file */
5268 line
= prepreproc(line
);
5269 tline
= tokenize(line
);
5275 * The current file has ended; work down the istk
5280 if (i
->expansion
!= NULL
) {
5282 "end of file while still in an expansion");
5284 /* only set line and file name if there's a next node */
5286 src_set_linnum(i
->lineno
);
5287 nasm_free(src_set_fname(nasm_strdup(i
->fname
)));
5289 if ((i
->next
== NULL
) && (finals
!= NULL
)) {
5291 ei
= new_ExpInv(EXP_FINAL
, NULL
);
5292 ei
->emitting
= true;
5293 ei
->current
= finals
;
5294 istk
->expansion
= ei
;
5299 list
->downlevel(LIST_INCLUDE
);
5302 if (finals
!= NULL
) {
5312 if (defining
== NULL
) {
5313 tline
= expand_mmac_params(tline
);
5317 * Check the line to see if it's a preprocessor directive.
5319 if (do_directive(tline
) == DIRECTIVE_FOUND
) {
5321 } else if (defining
!= NULL
) {
5323 * We're defining an expansion. We emit nothing at all,
5324 * and just shove the tokenized line on to the definition.
5326 if (defining
->ignoring
== false) {
5327 Line
*l
= new_Line();
5329 if (defining
->line
== NULL
) {
5333 defining
->last
->next
= l
;
5339 defining
->linecount
++;
5341 } else if ((istk
->expansion
!= NULL
) &&
5342 (istk
->expansion
->emitting
!= true)) {
5344 * We're in a non-emitting branch of an expansion.
5345 * Emit nothing at all, not even a blank line: when we
5346 * emerge from the expansion we'll give a line-number
5347 * directive so we keep our place correctly.
5352 tline
= expand_smacro(tline
);
5353 if (expand_mmacro(tline
) != true) {
5355 * De-tokenize the line again, and emit it.
5357 line
= detoken(tline
, true);
5368 static void pp_cleanup(int pass
)
5370 if (defining
!= NULL
) {
5371 error(ERR_NONFATAL
, "end of file while still defining an expansion");
5372 while (defining
!= NULL
) {
5373 ExpDef
*ed
= defining
;
5374 defining
= ed
->prev
;
5379 while (cstk
!= NULL
)
5382 while (istk
!= NULL
) {
5386 nasm_free(i
->fname
);
5387 while (i
->expansion
!= NULL
) {
5388 ExpInv
*ei
= i
->expansion
;
5389 i
->expansion
= ei
->prev
;
5396 nasm_free(src_set_fname(NULL
));
5401 while ((i
= ipath
)) {
5409 void pp_include_path(char *path
)
5411 IncPath
*i
= nasm_zalloc(sizeof(IncPath
));
5414 i
->path
= nasm_strdup(path
);
5426 void pp_pre_include(char *fname
)
5428 Token
*inc
, *space
, *name
;
5431 name
= new_Token(NULL
, TOK_INTERNAL_STRING
, fname
, 0);
5432 space
= new_Token(name
, TOK_WHITESPACE
, NULL
, 0);
5433 inc
= new_Token(space
, TOK_PREPROC_ID
, "%include", 0);
5441 void pp_pre_define(char *definition
)
5447 equals
= strchr(definition
, '=');
5448 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
5449 def
= new_Token(space
, TOK_PREPROC_ID
, "%define", 0);
5452 space
->next
= tokenize(definition
);
5462 void pp_pre_undefine(char *definition
)
5467 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
5468 def
= new_Token(space
, TOK_PREPROC_ID
, "%undef", 0);
5469 space
->next
= tokenize(definition
);
5478 * This function is used to assist with "runtime" preprocessor
5479 * directives, e.g. pp_runtime("%define __BITS__ 64");
5481 * ERRORS ARE IGNORED HERE, SO MAKE COMPLETELY SURE THAT YOU
5482 * PASS A VALID STRING TO THIS FUNCTION!!!!!
5485 void pp_runtime(char *definition
)
5489 def
= tokenize(definition
);
5490 if (do_directive(def
) == NO_DIRECTIVE_FOUND
)
5495 void pp_extra_stdmac(macros_t
*macros
)
5497 extrastdmac
= macros
;
5500 static void make_tok_num(Token
* tok
, int64_t val
)
5503 snprintf(numbuf
, sizeof(numbuf
), "%"PRId64
"", val
);
5504 tok
->text
= nasm_strdup(numbuf
);
5505 tok
->type
= TOK_NUMBER
;
5508 struct preproc_ops nasmpp
= {