1 /* -*- mode: c; c-file-style: "bsd" -*- */
2 /* preproc.c macro preprocessor for the Netwide Assembler
4 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
5 * Julian Hall. All rights reserved. The software is
6 * redistributable under the licence given in the file "Licence"
7 * distributed in the NASM archive.
9 * initial version 18/iii/97 by Simon Tatham
12 /* Typical flow of text through preproc
14 * pp_getline gets tokenised lines, either
16 * from a macro expansion
20 * read_line gets raw text from stdmacpos, or predef, or current input file
21 * tokenise converts to tokens
24 * expand_mmac_params is used to expand %1 etc., unless a macro is being
25 * defined or a false conditional is being processed
26 * (%0, %1, %+1, %-1, %%foo
28 * do_directive checks for directives
30 * expand_smacro is used to expand single line macros
32 * expand_mmacro is used to expand multi-line macros
34 * detoken is used to convert the line back to text
48 typedef struct SMacro SMacro
;
49 typedef struct MMacro MMacro
;
50 typedef struct Context Context
;
51 typedef struct Token Token
;
52 typedef struct Blocks Blocks
;
53 typedef struct Line Line
;
54 typedef struct Include Include
;
55 typedef struct Cond Cond
;
56 typedef struct IncPath IncPath
;
59 * Store the definition of a single-line macro.
72 * Store the definition of a multi-line macro. This is also used to
73 * store the interiors of `%rep...%endrep' blocks, which are
74 * effectively self-re-invoking multi-line macros which simply
75 * don't have a name or bother to appear in the hash tables. %rep
76 * blocks are signified by having a NULL `name' field.
78 * In a MMacro describing a `%rep' block, the `in_progress' field
79 * isn't merely boolean, but gives the number of repeats left to
82 * The `next' field is used for storing MMacros in hash tables; the
83 * `next_active' field is for stacking them on istk entries.
85 * When a MMacro is being expanded, `params', `iline', `nparam',
86 * `paramlen', `rotate' and `unique' are local to the invocation.
93 int nparam_min
, nparam_max
;
94 int plus
; /* is the last parameter greedy? */
95 int nolist
; /* is this macro listing-inhibited? */
97 Token
*dlist
; /* All defaults as one list */
98 Token
**defaults
; /* Parameter default pointers */
99 int ndefs
; /* number of default parameters */
103 MMacro
*rep_nest
; /* used for nesting %rep */
104 Token
**params
; /* actual parameters */
105 Token
*iline
; /* invocation line */
106 int nparam
, rotate
, *paramlen
;
107 unsigned long unique
;
108 int lineno
; /* Current line number on expansion */
112 * The context stack is composed of a linked list of these.
119 unsigned long number
;
123 * This is the internal form which we break input lines up into.
124 * Typically stored in linked lists.
126 * Note that `type' serves a double meaning: TOK_SMAC_PARAM is not
127 * necessarily used as-is, but is intended to denote the number of
128 * the substituted parameter. So in the definition
130 * %define a(x,y) ( (x) & ~(y) )
132 * the token representing `x' will have its type changed to
133 * TOK_SMAC_PARAM, but the one representing `y' will be
136 * TOK_INTERNAL_STRING is a dirty hack: it's a single string token
137 * which doesn't need quotes around it. Used in the pre-include
138 * mechanism as an alternative to trying to find a sensible type of
139 * quote to use on the filename we were passed.
145 SMacro
*mac
; /* associated macro for TOK_SMAC_END */
150 TOK_WHITESPACE
= 1, TOK_COMMENT
, TOK_ID
, TOK_PREPROC_ID
, TOK_STRING
,
151 TOK_NUMBER
, TOK_SMAC_END
, TOK_OTHER
, TOK_SMAC_PARAM
,
156 * Multi-line macro definitions are stored as a linked list of
157 * these, which is essentially a container to allow several linked
160 * Note that in this module, linked lists are treated as stacks
161 * wherever possible. For this reason, Lines are _pushed_ on to the
162 * `expansion' field in MMacro structures, so that the linked list,
163 * if walked, would give the macro lines in reverse order; this
164 * means that we can walk the list when expanding a macro, and thus
165 * push the lines on to the `expansion' field in _istk_ in reverse
166 * order (so that when popped back off they are in the right
167 * order). It may seem cockeyed, and it relies on my design having
168 * an even number of steps in, but it works...
170 * Some of these structures, rather than being actual lines, are
171 * markers delimiting the end of the expansion of a given macro.
172 * This is for use in the cycle-tracking and %rep-handling code.
173 * Such structures have `finishes' non-NULL, and `first' NULL. All
174 * others have `finishes' NULL, but `first' may still be NULL if
185 * To handle an arbitrary level of file inclusion, we maintain a
186 * stack (ie linked list) of these things.
196 MMacro
*mstk
; /* stack of active macros/reps */
200 * Include search path. This is simply a list of strings which get
201 * prepended, in turn, to the name of an include file, in an
202 * attempt to find the file if it's not in the current directory.
211 * Conditional assembly: we maintain a separate stack of these for
212 * each level of file inclusion. (The only reason we keep the
213 * stacks separate is to ensure that a stray `%endif' in a file
214 * included from within the true branch of a `%if' won't terminate
215 * it and cause confusion: instead, rightly, it'll cause an error.)
225 * These states are for use just after %if or %elif: IF_TRUE
226 * means the condition has evaluated to truth so we are
227 * currently emitting, whereas IF_FALSE means we are not
228 * currently emitting but will start doing so if a %else comes
229 * up. In these states, all directives are admissible: %elif,
230 * %else and %endif. (And of course %if.)
232 COND_IF_TRUE
, COND_IF_FALSE
,
234 * These states come up after a %else: ELSE_TRUE means we're
235 * emitting, and ELSE_FALSE means we're not. In ELSE_* states,
236 * any %elif or %else will cause an error.
238 COND_ELSE_TRUE
, COND_ELSE_FALSE
,
240 * This state means that we're not emitting now, and also that
241 * nothing until %endif will be emitted at all. It's for use in
242 * two circumstances: (i) when we've had our moment of emission
243 * and have now started seeing %elifs, and (ii) when the
244 * condition construct in question is contained within a
245 * non-emitting branch of a larger condition construct.
249 #define emitting(x) ( (x) == COND_IF_TRUE || (x) == COND_ELSE_TRUE )
252 * Condition codes. Note that we use c_ prefix not C_ because C_ is
253 * used in nasm.h for the "real" condition codes. At _this_ level,
254 * we treat CXZ and ECXZ as condition codes, albeit non-invertible
255 * ones, so we need a different enum...
257 static char *conditions
[] = {
258 "a", "ae", "b", "be", "c", "cxz", "e", "ecxz", "g", "ge", "l", "le",
259 "na", "nae", "nb", "nbe", "nc", "ne", "ng", "nge", "nl", "nle", "no",
260 "np", "ns", "nz", "o", "p", "pe", "po", "s", "z"
264 c_A
, c_AE
, c_B
, c_BE
, c_C
, c_CXZ
, c_E
, c_ECXZ
, c_G
, c_GE
, c_L
, c_LE
,
265 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, c_NE
, c_NG
, c_NGE
, c_NL
, c_NLE
, c_NO
,
266 c_NP
, c_NS
, c_NZ
, c_O
, c_P
, c_PE
, c_PO
, c_S
, c_Z
268 static int inverse_ccs
[] = {
269 c_NA
, c_NAE
, c_NB
, c_NBE
, c_NC
, -1, c_NE
, -1, c_NG
, c_NGE
, c_NL
, c_NLE
,
270 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
,
271 c_Z
, c_NO
, c_NP
, c_PO
, c_PE
, c_NS
, c_NZ
277 static char *directives
[] = {
279 "%assign", "%clear", "%define", "%elif", "%elifctx", "%elifdef",
280 "%elifid", "%elifidn", "%elifidni", "%elifmacro", "%elifnctx", "%elifndef",
281 "%elifnid", "%elifnidn", "%elifnidni", "%elifnmacro", "%elifnnum", "%elifnstr",
282 "%elifnum", "%elifstr", "%else", "%endif", "%endm", "%endmacro",
283 "%endrep", "%error", "%exitrep", "%iassign", "%idefine", "%if",
284 "%ifctx", "%ifdef", "%ifid", "%ifidn", "%ifidni", "%ifmacro", "%ifnctx",
285 "%ifndef", "%ifnid", "%ifnidn", "%ifnidni", "%ifnmacro", "%ifnnum",
286 "%ifnstr", "%ifnum", "%ifstr", "%imacro", "%include",
287 "%ixdefine", "%line",
289 "%macro", "%pop", "%push", "%rep", "%repl", "%rotate",
291 "%strlen", "%substr", "%undef", "%xdefine"
296 PP_ASSIGN
, PP_CLEAR
, PP_DEFINE
, PP_ELIF
, PP_ELIFCTX
, PP_ELIFDEF
,
297 PP_ELIFID
, PP_ELIFIDN
, PP_ELIFIDNI
, PP_ELIFMACRO
, PP_ELIFNCTX
, PP_ELIFNDEF
,
298 PP_ELIFNID
, PP_ELIFNIDN
, PP_ELIFNIDNI
, PP_ELIFNMACRO
, PP_ELIFNNUM
, PP_ELIFNSTR
,
299 PP_ELIFNUM
, PP_ELIFSTR
, PP_ELSE
, PP_ENDIF
, PP_ENDM
, PP_ENDMACRO
,
300 PP_ENDREP
, PP_ERROR
, PP_EXITREP
, PP_IASSIGN
, PP_IDEFINE
, PP_IF
,
301 PP_IFCTX
, PP_IFDEF
, PP_IFID
, PP_IFIDN
, PP_IFIDNI
, PP_IFMACRO
, PP_IFNCTX
,
302 PP_IFNDEF
, PP_IFNID
, PP_IFNIDN
, PP_IFNIDNI
, PP_IFNMACRO
, PP_IFNNUM
,
303 PP_IFNSTR
, PP_IFNUM
, PP_IFSTR
, PP_IMACRO
, PP_INCLUDE
,
304 PP_IXDEFINE
, PP_LINE
,
306 PP_MACRO
, PP_POP
, PP_PUSH
, PP_REP
, PP_REPL
, PP_ROTATE
,
308 PP_STRLEN
, PP_SUBSTR
, PP_UNDEF
, PP_XDEFINE
311 /* If this is a an IF, ELIF, ELSE or ENDIF keyword */
312 static int is_condition(int arg
)
314 return ((arg
>= PP_ELIF
) && (arg
<= PP_ENDIF
)) ||
315 ((arg
>= PP_IF
) && (arg
<= PP_IFSTR
));
318 /* For TASM compatibility we need to be able to recognise TASM compatible
319 * conditional compilation directives. Using the NASM pre-processor does
320 * not work, so we look for them specifically from the following list and
321 * then jam in the equivalent NASM directive into the input stream.
325 # define MAX(a,b) ( ((a) > (b)) ? (a) : (b))
330 TM_ARG
, TM_ELIF
, TM_ELSE
, TM_ENDIF
, TM_IF
, TM_IFDEF
, TM_IFDIFI
,
331 TM_IFNDEF
, TM_INCLUDE
, TM_LOCAL
334 static char *tasm_directives
[] = {
335 "arg", "elif", "else", "endif", "if", "ifdef", "ifdifi",
336 "ifndef", "include", "local"
339 static int StackSize
= 4;
340 static char *StackPointer
= "ebp";
341 static int ArgOffset
= 8;
342 static int LocalOffset
= 4;
345 static Context
*cstk
;
346 static Include
*istk
;
347 static IncPath
*ipath
= NULL
;
349 static efunc _error
; /* Pointer to client-provided error reporting function */
350 static evalfunc evaluate
;
352 static int pass
; /* HACK: pass 0 = generate dependencies only */
354 static unsigned long unique
; /* unique identifier numbers */
356 static Line
*predef
= NULL
;
358 static ListGen
*list
;
361 * The number of hash values we use for the macro lookup tables.
362 * FIXME: We should *really* be able to configure this at run time,
363 * or even have the hash table automatically expanding when necessary.
368 * The current set of multi-line macros we have defined.
370 static MMacro
*mmacros
[NHASH
];
373 * The current set of single-line macros we have defined.
375 static SMacro
*smacros
[NHASH
];
378 * The multi-line macro we are currently defining, or the %rep
379 * block we are currently reading, if any.
381 static MMacro
*defining
;
384 * The number of macro parameters to allocate space for at a time.
386 #define PARAM_DELTA 16
389 * The standard macro set: defined as `static char *stdmac[]'. Also
390 * gives our position in the macro set, when we're processing it.
393 static char **stdmacpos
;
396 * The extra standard macros that come from the object format, if
399 static char **extrastdmac
= NULL
;
403 * Tokens are allocated in blocks to improve speed
405 #define TOKEN_BLOCKSIZE 4096
406 static Token
*freeTokens
= NULL
;
412 static Blocks blocks
= { NULL
, NULL
};
415 * Forward declarations.
417 static Token
*expand_mmac_params(Token
* tline
);
418 static Token
*expand_smacro(Token
* tline
);
419 static Token
*expand_id(Token
* tline
);
420 static Context
*get_ctx(char *name
, int all_contexts
);
421 static void make_tok_num(Token
* tok
, long val
);
422 static void error(int severity
, char *fmt
, ...);
423 static void *new_Block(size_t size
);
424 static void delete_Blocks(void);
425 static Token
*new_Token(Token
* next
, int type
, char *text
, int txtlen
);
426 static Token
*delete_Token(Token
* t
);
429 * Macros for safe checking of token pointers, avoid *(NULL)
431 #define tok_type_(x,t) ((x) && (x)->type == (t))
432 #define skip_white_(x) if (tok_type_((x), TOK_WHITESPACE)) (x)=(x)->next
433 #define tok_is_(x,v) (tok_type_((x), TOK_OTHER) && !strcmp((x)->text,(v)))
434 #define tok_isnt_(x,v) ((x) && ((x)->type!=TOK_OTHER || strcmp((x)->text,(v))))
436 /* Handle TASM specific directives, which do not contain a % in
437 * front of them. We do it here because I could not find any other
438 * place to do it for the moment, and it is a hack (ideally it would
439 * be nice to be able to use the NASM pre-processor to do it).
442 check_tasm_directive(char *line
)
445 char *p
= line
, *oldline
, oldchar
;
447 /* Skip whitespace */
448 while (isspace(*p
) && *p
!= 0)
451 /* Binary search for the directive name */
453 j
= sizeof(tasm_directives
) / sizeof(*tasm_directives
);
455 while (!isspace(p
[len
]) && p
[len
] != 0)
464 m
= nasm_stricmp(p
, tasm_directives
[k
]);
467 /* We have found a directive, so jam a % in front of it
468 * so that NASM will then recognise it as one if it's own.
473 line
= nasm_malloc(len
+ 2);
477 /* NASM does not recognise IFDIFI, so we convert it to
478 * %ifdef BOGUS. This is not used in NASM comaptible
479 * code, but does need to parse for the TASM macro
482 strcpy(line
+ 1, "ifdef BOGUS");
486 memcpy(line
+ 1, p
, len
+ 1);
504 * The pre-preprocessing stage... This function translates line
505 * number indications as they emerge from GNU cpp (`# lineno "file"
506 * flags') into NASM preprocessor line number indications (`%line
510 prepreproc(char *line
)
513 char *fname
, *oldline
;
515 if (line
[0] == '#' && line
[1] == ' ')
519 lineno
= atoi(fname
);
520 fname
+= strspn(fname
, "0123456789 ");
523 fnlen
= strcspn(fname
, "\"");
524 line
= nasm_malloc(20 + fnlen
);
525 sprintf(line
, "%%line %d %.*s", lineno
, fnlen
, fname
);
528 if (tasm_compatible_mode
)
529 return check_tasm_directive(line
);
534 * The hash function for macro lookups. Note that due to some
535 * macros having case-insensitive names, the hash function must be
536 * invariant under case changes. We implement this by applying a
537 * perfectly normal hash function to the uppercase of the string.
545 * Powers of three, mod 31.
547 static const int multipliers
[] = {
548 1, 3, 9, 27, 19, 26, 16, 17, 20, 29, 25, 13, 8, 24, 10,
549 30, 28, 22, 4, 12, 5, 15, 14, 11, 2, 6, 18, 23, 7, 21
555 h
+= multipliers
[i
] * (unsigned char) (toupper(*s
));
557 if (++i
>= sizeof(multipliers
) / sizeof(*multipliers
))
565 * Free a linked list of tokens.
568 free_tlist(Token
* list
)
572 list
= delete_Token(list
);
577 * Free a linked list of lines.
580 free_llist(Line
* list
)
587 free_tlist(l
->first
);
596 free_mmacro(MMacro
* m
)
599 free_tlist(m
->dlist
);
600 nasm_free(m
->defaults
);
601 free_llist(m
->expansion
);
606 * Pop the context stack.
621 free_tlist(s
->expansion
);
628 #define BUF_DELTA 512
630 * Read a line from the top file in istk, handling multiple CR/LFs
631 * at the end of the line read, and handling spurious ^Zs. Will
632 * return lines from the standard macro set if this has not already
638 char *buffer
, *p
, *q
;
639 int bufsize
, continued_count
;
645 char *ret
= nasm_strdup(*stdmacpos
++);
646 if (!*stdmacpos
&& any_extrastdmac
)
648 stdmacpos
= extrastdmac
;
649 any_extrastdmac
= FALSE
;
653 * Nasty hack: here we push the contents of `predef' on
654 * to the top-level expansion stack, since this is the
655 * most convenient way to implement the pre-include and
656 * pre-define features.
661 Token
*head
, **tail
, *t
;
663 for (pd
= predef
; pd
; pd
= pd
->next
)
667 for (t
= pd
->first
; t
; t
= t
->next
)
669 *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
670 tail
= &(*tail
)->next
;
672 l
= nasm_malloc(sizeof(Line
));
673 l
->next
= istk
->expansion
;
688 buffer
= nasm_malloc(BUF_DELTA
);
693 q
= fgets(p
, bufsize
- (p
- buffer
), istk
->fp
);
697 if (p
> buffer
&& p
[-1] == '\n')
699 /* Convert backslash-CRLF line continuation sequences into
700 nothing at all (for DOS and Windows) */
701 if (((p
- 2) > buffer
) && (p
[-3] == '\\') && (p
[-2] == '\r')) {
706 /* Also convert backslash-LF line continuation sequences into
707 nothing at all (for Unix) */
708 else if (((p
- 1) > buffer
) && (p
[-2] == '\\')) {
717 if (p
- buffer
> bufsize
- 10)
719 long offset
= p
- buffer
;
720 bufsize
+= BUF_DELTA
;
721 buffer
= nasm_realloc(buffer
, bufsize
);
722 p
= buffer
+ offset
; /* prevent stale-pointer problems */
726 if (!q
&& p
== buffer
)
732 src_set_linnum(src_get_linnum() + istk
->lineinc
+ (continued_count
* istk
->lineinc
));
735 * Play safe: remove CRs as well as LFs, if any of either are
736 * present at the end of the line.
738 while (--p
>= buffer
&& (*p
== '\n' || *p
== '\r'))
742 * Handle spurious ^Z, which may be inserted into source files
743 * by some file transfer utilities.
745 buffer
[strcspn(buffer
, "\032")] = '\0';
747 list
->line(LIST_READ
, buffer
);
753 * Tokenise a line of text. This is a very simple process since we
754 * don't need to parse the value out of e.g. numeric tokens: we
755 * simply split one string into many.
763 Token
*t
, **tail
= &list
;
772 ((*p
== '-' || *p
== '+') && isdigit(p
[1])) ||
773 ((*p
== '+') && (isspace(p
[1]) || !p
[1])))
780 type
= TOK_PREPROC_ID
;
785 while (*p
&& *p
!= '}')
793 type
= TOK_PREPROC_ID
;
795 else if (isidchar(*p
) ||
796 ((*p
== '!' || *p
== '%' || *p
== '$') &&
803 while (isidchar(*p
));
804 type
= TOK_PREPROC_ID
;
813 else if (isidstart(*p
) || (*p
== '$' && isidstart(p
[1])))
817 while (*p
&& isidchar(*p
))
820 else if (*p
== '\'' || *p
== '"')
828 while (*p
&& *p
!= c
)
836 error(ERR_WARNING
, "unterminated string");
839 else if (isnumstart(*p
))
846 while (*p
&& isnumchar(*p
))
849 else if (isspace(*p
))
851 type
= TOK_WHITESPACE
;
853 while (*p
&& isspace(*p
))
856 * Whitespace just before end-of-line is discarded by
857 * pretending it's a comment; whitespace just before a
858 * comment gets lumped into the comment.
860 if (!*p
|| *p
== ';')
876 * Anything else is an operator of some kind. We check
877 * for all the double-character operators (>>, <<, //,
878 * %%, <=, >=, ==, !=, <>, &&, ||, ^^), but anything
879 * else is a single-character operator.
882 if ((p
[0] == '>' && p
[1] == '>') ||
883 (p
[0] == '<' && p
[1] == '<') ||
884 (p
[0] == '/' && p
[1] == '/') ||
885 (p
[0] == '<' && p
[1] == '=') ||
886 (p
[0] == '>' && p
[1] == '=') ||
887 (p
[0] == '=' && p
[1] == '=') ||
888 (p
[0] == '!' && p
[1] == '=') ||
889 (p
[0] == '<' && p
[1] == '>') ||
890 (p
[0] == '&' && p
[1] == '&') ||
891 (p
[0] == '|' && p
[1] == '|') ||
892 (p
[0] == '^' && p
[1] == '^'))
898 if (type
!= TOK_COMMENT
)
900 *tail
= t
= new_Token(NULL
, type
, line
, p
- line
);
909 * this function allocates a new managed block of memory and
910 * returns a pointer to the block. The managed blocks are
911 * deleted only all at once by the delete_Blocks function.
914 new_Block(size_t size
)
918 /* first, get to the end of the linked list */
921 /* now allocate the requested chunk */
922 b
->chunk
= nasm_malloc(size
);
924 /* now allocate a new block for the next request */
925 b
->next
= nasm_malloc(sizeof(Blocks
));
926 /* and initialize the contents of the new block */
927 b
->next
->next
= NULL
;
928 b
->next
->chunk
= NULL
;
933 * this function deletes all managed blocks of memory
938 Blocks
*a
,*b
= &blocks
;
941 * keep in mind that the first block, pointed to by blocks
942 * is a static and not dynamically allocated, so we don't
957 * this function creates a new Token and passes a pointer to it
958 * back to the caller. It sets the type and text elements, and
959 * also the mac and next elements to NULL.
962 new_Token(Token
* next
, int type
, char *text
, int txtlen
)
967 if (freeTokens
== NULL
)
969 freeTokens
= (Token
*)new_Block(TOKEN_BLOCKSIZE
* sizeof(Token
));
970 for (i
= 0; i
< TOKEN_BLOCKSIZE
- 1; i
++)
971 freeTokens
[i
].next
= &freeTokens
[i
+ 1];
972 freeTokens
[i
].next
= NULL
;
975 freeTokens
= t
->next
;
979 if (type
== TOK_WHITESPACE
|| text
== NULL
)
986 txtlen
= strlen(text
);
987 t
->text
= nasm_malloc(1 + txtlen
);
988 strncpy(t
->text
, text
, txtlen
);
989 t
->text
[txtlen
] = '\0';
995 delete_Token(Token
* t
)
997 Token
*next
= t
->next
;
999 t
->next
= freeTokens
;
1005 * Convert a line of tokens back into text.
1006 * If expand_locals is not zero, identifiers of the form "%$*xxx"
1007 * will be transformed into ..@ctxnum.xxx
1010 detoken(Token
* tlist
, int expand_locals
)
1017 for (t
= tlist
; t
; t
= t
->next
)
1019 if (t
->type
== TOK_PREPROC_ID
&& t
->text
[1] == '!')
1021 char *p
= getenv(t
->text
+ 2);
1024 t
->text
= nasm_strdup(p
);
1028 /* Expand local macros here and not during preprocessing */
1029 if (expand_locals
&&
1030 t
->type
== TOK_PREPROC_ID
&& t
->text
&&
1031 t
->text
[0] == '%' && t
->text
[1] == '$')
1033 Context
*ctx
= get_ctx(t
->text
, FALSE
);
1037 char *p
, *q
= t
->text
+ 2;
1039 q
+= strspn(q
, "$");
1040 sprintf(buffer
, "..@%lu.", ctx
->number
);
1041 p
= nasm_strcat(buffer
, q
);
1046 if (t
->type
== TOK_WHITESPACE
)
1052 len
+= strlen(t
->text
);
1055 p
= line
= nasm_malloc(len
+ 1);
1056 for (t
= tlist
; t
; t
= t
->next
)
1058 if (t
->type
== TOK_WHITESPACE
)
1075 * A scanner, suitable for use by the expression evaluator, which
1076 * operates on a line of Tokens. Expects a pointer to a pointer to
1077 * the first token in the line to be passed in as its private_data
1081 ppscan(void *private_data
, struct tokenval
*tokval
)
1083 Token
**tlineptr
= private_data
;
1089 *tlineptr
= tline
? tline
->next
: NULL
;
1091 while (tline
&& (tline
->type
== TOK_WHITESPACE
||
1092 tline
->type
== TOK_COMMENT
));
1095 return tokval
->t_type
= TOKEN_EOS
;
1097 if (tline
->text
[0] == '$' && !tline
->text
[1])
1098 return tokval
->t_type
= TOKEN_HERE
;
1099 if (tline
->text
[0] == '$' && tline
->text
[1] == '$' && !tline
->text
[1])
1100 return tokval
->t_type
= TOKEN_BASE
;
1102 if (tline
->type
== TOK_ID
)
1104 tokval
->t_charptr
= tline
->text
;
1105 if (tline
->text
[0] == '$')
1107 tokval
->t_charptr
++;
1108 return tokval
->t_type
= TOKEN_ID
;
1112 * This is the only special case we actually need to worry
1113 * about in this restricted context.
1115 if (!nasm_stricmp(tline
->text
, "seg"))
1116 return tokval
->t_type
= TOKEN_SEG
;
1118 return tokval
->t_type
= TOKEN_ID
;
1121 if (tline
->type
== TOK_NUMBER
)
1125 tokval
->t_integer
= readnum(tline
->text
, &rn_error
);
1127 return tokval
->t_type
= TOKEN_ERRNUM
;
1128 tokval
->t_charptr
= NULL
;
1129 return tokval
->t_type
= TOKEN_NUM
;
1132 if (tline
->type
== TOK_STRING
)
1142 if (l
== 0 || r
[l
- 1] != q
)
1143 return tokval
->t_type
= TOKEN_ERRNUM
;
1144 tokval
->t_integer
= readstrnum(r
, l
- 1, &rn_warn
);
1146 error(ERR_WARNING
| ERR_PASS1
, "character constant too long");
1147 tokval
->t_charptr
= NULL
;
1148 return tokval
->t_type
= TOKEN_NUM
;
1151 if (tline
->type
== TOK_OTHER
)
1153 if (!strcmp(tline
->text
, "<<"))
1154 return tokval
->t_type
= TOKEN_SHL
;
1155 if (!strcmp(tline
->text
, ">>"))
1156 return tokval
->t_type
= TOKEN_SHR
;
1157 if (!strcmp(tline
->text
, "//"))
1158 return tokval
->t_type
= TOKEN_SDIV
;
1159 if (!strcmp(tline
->text
, "%%"))
1160 return tokval
->t_type
= TOKEN_SMOD
;
1161 if (!strcmp(tline
->text
, "=="))
1162 return tokval
->t_type
= TOKEN_EQ
;
1163 if (!strcmp(tline
->text
, "<>"))
1164 return tokval
->t_type
= TOKEN_NE
;
1165 if (!strcmp(tline
->text
, "!="))
1166 return tokval
->t_type
= TOKEN_NE
;
1167 if (!strcmp(tline
->text
, "<="))
1168 return tokval
->t_type
= TOKEN_LE
;
1169 if (!strcmp(tline
->text
, ">="))
1170 return tokval
->t_type
= TOKEN_GE
;
1171 if (!strcmp(tline
->text
, "&&"))
1172 return tokval
->t_type
= TOKEN_DBL_AND
;
1173 if (!strcmp(tline
->text
, "^^"))
1174 return tokval
->t_type
= TOKEN_DBL_XOR
;
1175 if (!strcmp(tline
->text
, "||"))
1176 return tokval
->t_type
= TOKEN_DBL_OR
;
1180 * We have no other options: just return the first character of
1183 return tokval
->t_type
= tline
->text
[0];
1187 * Compare a string to the name of an existing macro; this is a
1188 * simple wrapper which calls either strcmp or nasm_stricmp
1189 * depending on the value of the `casesense' parameter.
1192 mstrcmp(char *p
, char *q
, int casesense
)
1194 return casesense
? strcmp(p
, q
) : nasm_stricmp(p
, q
);
1198 * Return the Context structure associated with a %$ token. Return
1199 * NULL, having _already_ reported an error condition, if the
1200 * context stack isn't deep enough for the supplied number of $
1202 * If all_contexts == TRUE, contexts that enclose current are
1203 * also scanned for such smacro, until it is found; if not -
1204 * only the context that directly results from the number of $'s
1205 * in variable's name.
1208 get_ctx(char *name
, int all_contexts
)
1214 if (!name
|| name
[0] != '%' || name
[1] != '$')
1219 error(ERR_NONFATAL
, "`%s': context stack is empty", name
);
1223 for (i
= strspn(name
+ 2, "$"), ctx
= cstk
; (i
> 0) && ctx
; i
--)
1226 /* i--; Lino - 02/25/02 */
1230 error(ERR_NONFATAL
, "`%s': context stack is only"
1231 " %d level%s deep", name
, i
- 1, (i
== 2 ? "" : "s"));
1239 /* Search for this smacro in found context */
1243 if (!mstrcmp(m
->name
, name
, m
->casesense
))
1253 /* Add a slash to the end of a path if it is missing. We use the
1254 * forward slash to make it compatible with Unix systems.
1259 int pos
= strlen(s
);
1260 if (s
[pos
- 1] != '\\' && s
[pos
- 1] != '/')
1268 * Open an include file. This routine must always return a valid
1269 * file pointer if it returns - it's responsible for throwing an
1270 * ERR_FATAL and bombing out completely if not. It should also try
1271 * the include path one by one until it finds the file or reaches
1272 * the end of the path.
1275 inc_fopen(char *file
)
1278 char *prefix
= "", *combine
;
1279 IncPath
*ip
= ipath
;
1280 static int namelen
= 0;
1281 int len
= strlen(file
);
1285 combine
= nasm_malloc(strlen(prefix
) + 1 + len
+ 1);
1286 strcpy(combine
, prefix
);
1289 strcat(combine
, file
);
1290 fp
= fopen(combine
, "r");
1291 if (pass
== 0 && fp
)
1293 namelen
+= strlen(combine
) + 1;
1299 printf(" %s", combine
);
1310 error(ERR_FATAL
, "unable to open include file `%s'", file
);
1311 return NULL
; /* never reached - placate compilers */
1315 * Determine if we should warn on defining a single-line macro of
1316 * name `name', with `nparam' parameters. If nparam is 0 or -1, will
1317 * return TRUE if _any_ single-line macro of that name is defined.
1318 * Otherwise, will return TRUE if a single-line macro with either
1319 * `nparam' or no parameters is defined.
1321 * If a macro with precisely the right number of parameters is
1322 * defined, or nparam is -1, the address of the definition structure
1323 * will be returned in `defn'; otherwise NULL will be returned. If `defn'
1324 * is NULL, no action will be taken regarding its contents, and no
1327 * Note that this is also called with nparam zero to resolve
1330 * If you already know which context macro belongs to, you can pass
1331 * the context pointer as first parameter; if you won't but name begins
1332 * with %$ the context will be automatically computed. If all_contexts
1333 * is true, macro will be searched in outer contexts as well.
1336 smacro_defined(Context
* ctx
, char *name
, int nparam
, SMacro
** defn
,
1343 else if (name
[0] == '%' && name
[1] == '$')
1346 ctx
= get_ctx(name
, FALSE
);
1348 return FALSE
; /* got to return _something_ */
1352 m
= smacros
[hash(name
)];
1356 if (!mstrcmp(m
->name
, name
, m
->casesense
&& nocase
) &&
1357 (nparam
<= 0 || m
->nparam
== 0 || nparam
== m
->nparam
))
1361 if (nparam
== m
->nparam
|| nparam
== -1)
1375 * Count and mark off the parameters in a multi-line macro call.
1376 * This is called both from within the multi-line macro expansion
1377 * code, and also to mark off the default parameters when provided
1378 * in a %macro definition line.
1381 count_mmac_params(Token
* t
, int *nparam
, Token
*** params
)
1383 int paramsize
, brace
;
1385 *nparam
= paramsize
= 0;
1389 if (*nparam
>= paramsize
)
1391 paramsize
+= PARAM_DELTA
;
1392 *params
= nasm_realloc(*params
, sizeof(**params
) * paramsize
);
1396 if (tok_is_(t
, "{"))
1398 (*params
)[(*nparam
)++] = t
;
1399 while (tok_isnt_(t
, brace
? "}" : ","))
1402 { /* got a comma/brace */
1407 * Now we've found the closing brace, look further
1411 if (tok_isnt_(t
, ","))
1414 "braces do not enclose all of macro parameter");
1415 while (tok_isnt_(t
, ","))
1419 t
= t
->next
; /* eat the comma */
1426 * Determine whether one of the various `if' conditions is true or
1429 * We must free the tline we get passed.
1432 if_condition(Token
* tline
, int i
)
1435 Token
*t
, *tt
, **tptr
, *origline
;
1436 struct tokenval tokval
;
1447 j
= FALSE
; /* have we matched yet? */
1448 while (cstk
&& tline
)
1451 if (!tline
|| tline
->type
!= TOK_ID
)
1454 "`%s' expects context identifiers",
1456 free_tlist(origline
);
1459 if (!nasm_stricmp(tline
->text
, cstk
->name
))
1461 tline
= tline
->next
;
1463 if (i
== PP_IFNCTX
|| i
== PP_ELIFNCTX
)
1465 free_tlist(origline
);
1472 j
= FALSE
; /* have we matched yet? */
1476 if (!tline
|| (tline
->type
!= TOK_ID
&&
1477 (tline
->type
!= TOK_PREPROC_ID
||
1478 tline
->text
[1] != '$')))
1481 "`%s' expects macro identifiers",
1483 free_tlist(origline
);
1486 if (smacro_defined(NULL
, tline
->text
, 0, NULL
, 1))
1488 tline
= tline
->next
;
1490 if (i
== PP_IFNDEF
|| i
== PP_ELIFNDEF
)
1492 free_tlist(origline
);
1503 tline
= expand_smacro(tline
);
1505 while (tok_isnt_(tt
, ","))
1510 "`%s' expects two comma-separated arguments",
1516 casesense
= (i
== PP_IFIDN
|| i
== PP_ELIFIDN
||
1517 i
== PP_IFNIDN
|| i
== PP_ELIFNIDN
);
1518 j
= TRUE
; /* assume equality unless proved not */
1519 while ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) && tt
)
1521 if (tt
->type
== TOK_OTHER
&& !strcmp(tt
->text
, ","))
1523 error(ERR_NONFATAL
, "`%s': more than one comma on line",
1528 if (t
->type
== TOK_WHITESPACE
)
1533 else if (tt
->type
== TOK_WHITESPACE
)
1538 else if (tt
->type
!= t
->type
||
1539 mstrcmp(tt
->text
, t
->text
, casesense
))
1541 j
= FALSE
; /* found mismatching tokens */
1551 if ((t
->type
!= TOK_OTHER
|| strcmp(t
->text
, ",")) || tt
)
1552 j
= FALSE
; /* trailing gunk on one end or other */
1553 if (i
== PP_IFNIDN
|| i
== PP_ELIFNIDN
||
1554 i
== PP_IFNIDNI
|| i
== PP_ELIFNIDNI
)
1565 MMacro searching
, *mmac
;
1567 tline
= tline
->next
;
1569 tline
= expand_id(tline
);
1570 if (!tok_type_(tline
, TOK_ID
))
1573 "`%s' expects a macro name",
1577 searching
.name
= nasm_strdup(tline
->text
);
1578 searching
.casesense
= (i
== PP_MACRO
);
1579 searching
.plus
= FALSE
;
1580 searching
.nolist
= FALSE
;
1581 searching
.in_progress
= FALSE
;
1582 searching
.rep_nest
= NULL
;
1583 searching
.nparam_min
= 0;
1584 searching
.nparam_max
= INT_MAX
;
1585 tline
= expand_smacro(tline
->next
);
1589 } else if (!tok_type_(tline
, TOK_NUMBER
))
1592 "`%s' expects a parameter count or nothing",
1597 searching
.nparam_min
= searching
.nparam_max
=
1598 readnum(tline
->text
, &j
);
1601 "unable to parse parameter count `%s'",
1604 if (tline
&& tok_is_(tline
->next
, "-"))
1606 tline
= tline
->next
->next
;
1607 if (tok_is_(tline
, "*"))
1608 searching
.nparam_max
= INT_MAX
;
1609 else if (!tok_type_(tline
, TOK_NUMBER
))
1611 "`%s' expects a parameter count after `-'",
1615 searching
.nparam_max
= readnum(tline
->text
, &j
);
1618 "unable to parse parameter count `%s'",
1620 if (searching
.nparam_min
> searching
.nparam_max
)
1622 "minimum parameter count exceeds maximum");
1625 if (tline
&& tok_is_(tline
->next
, "+"))
1627 tline
= tline
->next
;
1628 searching
.plus
= TRUE
;
1630 mmac
= mmacros
[hash(searching
.name
)];
1633 if (!strcmp(mmac
->name
, searching
.name
) &&
1634 (mmac
->nparam_min
<= searching
.nparam_max
1636 && (searching
.nparam_min
<= mmac
->nparam_max
1644 nasm_free(searching
.name
);
1645 free_tlist(origline
);
1646 if (i
== PP_IFNMACRO
|| i
== PP_ELIFNMACRO
)
1663 tline
= expand_smacro(tline
);
1665 while (tok_type_(t
, TOK_WHITESPACE
))
1667 j
= FALSE
; /* placate optimiser */
1675 j
= (t
->type
== TOK_ID
);
1681 j
= (t
->type
== TOK_NUMBER
);
1687 j
= (t
->type
== TOK_STRING
);
1690 if (i
== PP_IFNID
|| i
== PP_ELIFNID
||
1691 i
== PP_IFNNUM
|| i
== PP_ELIFNNUM
||
1692 i
== PP_IFNSTR
|| i
== PP_ELIFNSTR
)
1699 t
= tline
= expand_smacro(tline
);
1701 tokval
.t_type
= TOKEN_INVALID
;
1702 evalresult
= evaluate(ppscan
, tptr
, &tokval
,
1703 NULL
, pass
| CRITICAL
, error
, NULL
);
1709 "trailing garbage after expression ignored");
1710 if (!is_simple(evalresult
))
1713 "non-constant value given to `%s'", directives
[i
]);
1716 return reloc_value(evalresult
) != 0;
1720 "preprocessor directive `%s' not yet implemented",
1722 free_tlist(origline
);
1723 return -1; /* yeah, right */
1728 * Expand macros in a string. Used in %error and %include directives.
1729 * First tokenise the string, apply "expand_smacro" and then de-tokenise back.
1730 * The returned variable should ALWAYS be freed after usage.
1733 expand_macros_in_string(char **p
)
1735 Token
*line
= tokenise(*p
);
1736 line
= expand_smacro(line
);
1737 *p
= detoken(line
, FALSE
);
1741 * Find out if a line contains a preprocessor directive, and deal
1744 * If a directive _is_ found, we are expected to free_tlist() the
1747 * Return values go like this:
1749 * bit 0 is set if a directive was found (so the line gets freed)
1752 do_directive(Token
* tline
)
1754 int i
, j
, k
, m
, nparam
, nolist
;
1760 SMacro
*smac
, **smhead
;
1762 Token
*t
, *tt
, *param_start
, *macro_start
, *last
, **tptr
, *origline
;
1764 struct tokenval tokval
;
1766 MMacro
*tmp_defining
; /* Used when manipulating rep_nest */
1771 if (!tok_type_(tline
, TOK_PREPROC_ID
) ||
1772 (tline
->text
[1] == '%' || tline
->text
[1] == '$'
1773 || tline
->text
[1] == '!'))
1777 j
= sizeof(directives
) / sizeof(*directives
);
1781 m
= nasm_stricmp(tline
->text
, directives
[k
]);
1783 if (tasm_compatible_mode
) {
1786 } else if (k
!= PP_ARG
&& k
!= PP_LOCAL
&& k
!= PP_STACKSIZE
) {
1800 * If we're in a non-emitting branch of a condition construct,
1801 * or walking to the end of an already terminated %rep block,
1802 * we should ignore all directives except for condition
1805 if (((istk
->conds
&& !emitting(istk
->conds
->state
)) ||
1806 (istk
->mstk
&& !istk
->mstk
->in_progress
)) &&
1813 * If we're defining a macro or reading a %rep block, we should
1814 * ignore all directives except for %macro/%imacro (which
1815 * generate an error), %endm/%endmacro, and (only if we're in a
1816 * %rep block) %endrep. If we're in a %rep block, another %rep
1817 * causes an error, so should be let through.
1819 if (defining
&& i
!= PP_MACRO
&& i
!= PP_IMACRO
&&
1820 i
!= PP_ENDMACRO
&& i
!= PP_ENDM
&&
1821 (defining
->name
|| (i
!= PP_ENDREP
&& i
!= PP_REP
)))
1828 error(ERR_NONFATAL
, "unknown preprocessor directive `%s'",
1830 return 0; /* didn't get it */
1836 /* Directive to tell NASM what the default stack size is. The
1837 * default is for a 16-bit stack, and this can be overriden with
1839 * the following form:
1841 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1843 tline
= tline
->next
;
1844 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1845 tline
= tline
->next
;
1846 if (!tline
|| tline
->type
!= TOK_ID
)
1848 error(ERR_NONFATAL
, "`%%stacksize' missing size parameter");
1849 free_tlist(origline
);
1852 if (nasm_stricmp(tline
->text
, "flat") == 0)
1854 /* All subsequent ARG directives are for a 32-bit stack */
1856 StackPointer
= "ebp";
1860 else if (nasm_stricmp(tline
->text
, "large") == 0)
1862 /* All subsequent ARG directives are for a 16-bit stack,
1863 * far function call.
1866 StackPointer
= "bp";
1870 else if (nasm_stricmp(tline
->text
, "small") == 0)
1872 /* All subsequent ARG directives are for a 16-bit stack,
1873 * far function call. We don't support near functions.
1876 StackPointer
= "bp";
1882 error(ERR_NONFATAL
, "`%%stacksize' invalid size type");
1883 free_tlist(origline
);
1886 free_tlist(origline
);
1890 /* TASM like ARG directive to define arguments to functions, in
1891 * the following form:
1893 * ARG arg1:WORD, arg2:DWORD, arg4:QWORD
1898 char *arg
, directive
[256];
1899 int size
= StackSize
;
1901 /* Find the argument name */
1902 tline
= tline
->next
;
1903 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1904 tline
= tline
->next
;
1905 if (!tline
|| tline
->type
!= TOK_ID
)
1907 error(ERR_NONFATAL
, "`%%arg' missing argument parameter");
1908 free_tlist(origline
);
1913 /* Find the argument size type */
1914 tline
= tline
->next
;
1915 if (!tline
|| tline
->type
!= TOK_OTHER
1916 || tline
->text
[0] != ':')
1919 "Syntax error processing `%%arg' directive");
1920 free_tlist(origline
);
1923 tline
= tline
->next
;
1924 if (!tline
|| tline
->type
!= TOK_ID
)
1927 "`%%arg' missing size type parameter");
1928 free_tlist(origline
);
1932 /* Allow macro expansion of type parameter */
1933 tt
= tokenise(tline
->text
);
1934 tt
= expand_smacro(tt
);
1935 if (nasm_stricmp(tt
->text
, "byte") == 0)
1937 size
= MAX(StackSize
, 1);
1939 else if (nasm_stricmp(tt
->text
, "word") == 0)
1941 size
= MAX(StackSize
, 2);
1943 else if (nasm_stricmp(tt
->text
, "dword") == 0)
1945 size
= MAX(StackSize
, 4);
1947 else if (nasm_stricmp(tt
->text
, "qword") == 0)
1949 size
= MAX(StackSize
, 8);
1951 else if (nasm_stricmp(tt
->text
, "tword") == 0)
1953 size
= MAX(StackSize
, 10);
1958 "Invalid size type for `%%arg' missing directive");
1960 free_tlist(origline
);
1965 /* Now define the macro for the argument */
1966 sprintf(directive
, "%%define %s (%s+%d)", arg
, StackPointer
,
1968 do_directive(tokenise(directive
));
1971 /* Move to the next argument in the list */
1972 tline
= tline
->next
;
1973 if (tline
&& tline
->type
== TOK_WHITESPACE
)
1974 tline
= tline
->next
;
1976 while (tline
&& tline
->type
== TOK_OTHER
1977 && tline
->text
[0] == ',');
1978 free_tlist(origline
);
1982 /* TASM like LOCAL directive to define local variables for a
1983 * function, in the following form:
1985 * LOCAL local1:WORD, local2:DWORD, local4:QWORD = LocalSize
1987 * The '= LocalSize' at the end is ignored by NASM, but is
1988 * required by TASM to define the local parameter size (and used
1989 * by the TASM macro package).
1991 offset
= LocalOffset
;
1994 char *local
, directive
[256];
1995 int size
= StackSize
;
1997 /* Find the argument name */
1998 tline
= tline
->next
;
1999 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2000 tline
= tline
->next
;
2001 if (!tline
|| tline
->type
!= TOK_ID
)
2004 "`%%local' missing argument parameter");
2005 free_tlist(origline
);
2008 local
= tline
->text
;
2010 /* Find the argument size type */
2011 tline
= tline
->next
;
2012 if (!tline
|| tline
->type
!= TOK_OTHER
2013 || tline
->text
[0] != ':')
2016 "Syntax error processing `%%local' directive");
2017 free_tlist(origline
);
2020 tline
= tline
->next
;
2021 if (!tline
|| tline
->type
!= TOK_ID
)
2024 "`%%local' missing size type parameter");
2025 free_tlist(origline
);
2029 /* Allow macro expansion of type parameter */
2030 tt
= tokenise(tline
->text
);
2031 tt
= expand_smacro(tt
);
2032 if (nasm_stricmp(tt
->text
, "byte") == 0)
2034 size
= MAX(StackSize
, 1);
2036 else if (nasm_stricmp(tt
->text
, "word") == 0)
2038 size
= MAX(StackSize
, 2);
2040 else if (nasm_stricmp(tt
->text
, "dword") == 0)
2042 size
= MAX(StackSize
, 4);
2044 else if (nasm_stricmp(tt
->text
, "qword") == 0)
2046 size
= MAX(StackSize
, 8);
2048 else if (nasm_stricmp(tt
->text
, "tword") == 0)
2050 size
= MAX(StackSize
, 10);
2055 "Invalid size type for `%%local' missing directive");
2057 free_tlist(origline
);
2062 /* Now define the macro for the argument */
2063 sprintf(directive
, "%%define %s (%s-%d)", local
, StackPointer
,
2065 do_directive(tokenise(directive
));
2068 /* Now define the assign to setup the enter_c macro correctly */
2069 sprintf(directive
, "%%assign %%$localsize %%$localsize+%d",
2071 do_directive(tokenise(directive
));
2073 /* Move to the next argument in the list */
2074 tline
= tline
->next
;
2075 if (tline
&& tline
->type
== TOK_WHITESPACE
)
2076 tline
= tline
->next
;
2078 while (tline
&& tline
->type
== TOK_OTHER
2079 && tline
->text
[0] == ',');
2080 free_tlist(origline
);
2086 "trailing garbage after `%%clear' ignored");
2087 for (j
= 0; j
< NHASH
; j
++)
2091 MMacro
*m
= mmacros
[j
];
2092 mmacros
[j
] = m
->next
;
2097 SMacro
*s
= smacros
[j
];
2098 smacros
[j
] = smacros
[j
]->next
;
2100 free_tlist(s
->expansion
);
2104 free_tlist(origline
);
2108 tline
= tline
->next
;
2110 if (!tline
|| (tline
->type
!= TOK_STRING
&&
2111 tline
->type
!= TOK_INTERNAL_STRING
))
2113 error(ERR_NONFATAL
, "`%%include' expects a file name");
2114 free_tlist(origline
);
2115 return 3; /* but we did _something_ */
2119 "trailing garbage after `%%include' ignored");
2120 if (tline
->type
!= TOK_INTERNAL_STRING
)
2122 p
= tline
->text
+ 1; /* point past the quote to the name */
2123 p
[strlen(p
) - 1] = '\0'; /* remove the trailing quote */
2126 p
= tline
->text
; /* internal_string is easier */
2127 expand_macros_in_string(&p
);
2128 inc
= nasm_malloc(sizeof(Include
));
2131 inc
->fp
= inc_fopen(p
);
2132 inc
->fname
= src_set_fname(p
);
2133 inc
->lineno
= src_set_linnum(0);
2135 inc
->expansion
= NULL
;
2138 list
->uplevel(LIST_INCLUDE
);
2139 free_tlist(origline
);
2143 tline
= tline
->next
;
2145 tline
= expand_id(tline
);
2146 if (!tok_type_(tline
, TOK_ID
))
2148 error(ERR_NONFATAL
, "`%%push' expects a context identifier");
2149 free_tlist(origline
);
2150 return 3; /* but we did _something_ */
2153 error(ERR_WARNING
, "trailing garbage after `%%push' ignored");
2154 ctx
= nasm_malloc(sizeof(Context
));
2156 ctx
->localmac
= NULL
;
2157 ctx
->name
= nasm_strdup(tline
->text
);
2158 ctx
->number
= unique
++;
2160 free_tlist(origline
);
2164 tline
= tline
->next
;
2166 tline
= expand_id(tline
);
2167 if (!tok_type_(tline
, TOK_ID
))
2169 error(ERR_NONFATAL
, "`%%repl' expects a context identifier");
2170 free_tlist(origline
);
2171 return 3; /* but we did _something_ */
2174 error(ERR_WARNING
, "trailing garbage after `%%repl' ignored");
2176 error(ERR_NONFATAL
, "`%%repl': context stack is empty");
2179 nasm_free(cstk
->name
);
2180 cstk
->name
= nasm_strdup(tline
->text
);
2182 free_tlist(origline
);
2187 error(ERR_WARNING
, "trailing garbage after `%%pop' ignored");
2190 "`%%pop': context stack is already empty");
2193 free_tlist(origline
);
2197 tline
->next
= expand_smacro(tline
->next
);
2198 tline
= tline
->next
;
2200 if (tok_type_(tline
, TOK_STRING
))
2202 p
= tline
->text
+ 1; /* point past the quote to the name */
2203 p
[strlen(p
) - 1] = '\0'; /* remove the trailing quote */
2204 expand_macros_in_string(&p
);
2205 error(ERR_NONFATAL
, "%s", p
);
2210 p
= detoken(tline
, FALSE
);
2211 error(ERR_WARNING
, "%s", p
);
2214 free_tlist(origline
);
2234 if (istk
->conds
&& !emitting(istk
->conds
->state
))
2238 j
= if_condition(tline
->next
, i
);
2239 tline
->next
= NULL
; /* it got freed */
2240 free_tlist(origline
);
2241 j
= j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2243 cond
= nasm_malloc(sizeof(Cond
));
2244 cond
->next
= istk
->conds
;
2247 return (j
== COND_IF_TRUE
? 3 : 1);
2267 error(ERR_FATAL
, "`%s': no matching `%%if'", directives
[i
]);
2268 if (emitting(istk
->conds
->state
)
2269 || istk
->conds
->state
== COND_NEVER
)
2270 istk
->conds
->state
= COND_NEVER
;
2273 j
= if_condition(tline
->next
, i
);
2274 tline
->next
= NULL
; /* it got freed */
2275 free_tlist(origline
);
2276 istk
->conds
->state
=
2277 j
< 0 ? COND_NEVER
: j
? COND_IF_TRUE
: COND_IF_FALSE
;
2279 return (istk
->conds
->state
== COND_IF_TRUE
? 5 : 1);
2283 error(ERR_WARNING
, "trailing garbage after `%%else' ignored");
2285 error(ERR_FATAL
, "`%%else': no matching `%%if'");
2286 if (emitting(istk
->conds
->state
)
2287 || istk
->conds
->state
== COND_NEVER
)
2288 istk
->conds
->state
= COND_ELSE_FALSE
;
2290 istk
->conds
->state
= COND_ELSE_TRUE
;
2291 free_tlist(origline
);
2297 "trailing garbage after `%%endif' ignored");
2299 error(ERR_FATAL
, "`%%endif': no matching `%%if'");
2301 istk
->conds
= cond
->next
;
2303 free_tlist(origline
);
2310 "`%%%smacro': already defining a macro",
2311 (i
== PP_IMACRO
? "i" : ""));
2312 tline
= tline
->next
;
2314 tline
= expand_id(tline
);
2315 if (!tok_type_(tline
, TOK_ID
))
2318 "`%%%smacro' expects a macro name",
2319 (i
== PP_IMACRO
? "i" : ""));
2322 defining
= nasm_malloc(sizeof(MMacro
));
2323 defining
->name
= nasm_strdup(tline
->text
);
2324 defining
->casesense
= (i
== PP_MACRO
);
2325 defining
->plus
= FALSE
;
2326 defining
->nolist
= FALSE
;
2327 defining
->in_progress
= FALSE
;
2328 defining
->rep_nest
= NULL
;
2329 tline
= expand_smacro(tline
->next
);
2331 if (!tok_type_(tline
, TOK_NUMBER
))
2334 "`%%%smacro' expects a parameter count",
2335 (i
== PP_IMACRO
? "i" : ""));
2336 defining
->nparam_min
= defining
->nparam_max
= 0;
2340 defining
->nparam_min
= defining
->nparam_max
=
2341 readnum(tline
->text
, &j
);
2344 "unable to parse parameter count `%s'",
2347 if (tline
&& tok_is_(tline
->next
, "-"))
2349 tline
= tline
->next
->next
;
2350 if (tok_is_(tline
, "*"))
2351 defining
->nparam_max
= INT_MAX
;
2352 else if (!tok_type_(tline
, TOK_NUMBER
))
2354 "`%%%smacro' expects a parameter count after `-'",
2355 (i
== PP_IMACRO
? "i" : ""));
2358 defining
->nparam_max
= readnum(tline
->text
, &j
);
2361 "unable to parse parameter count `%s'",
2363 if (defining
->nparam_min
> defining
->nparam_max
)
2365 "minimum parameter count exceeds maximum");
2368 if (tline
&& tok_is_(tline
->next
, "+"))
2370 tline
= tline
->next
;
2371 defining
->plus
= TRUE
;
2373 if (tline
&& tok_type_(tline
->next
, TOK_ID
) &&
2374 !nasm_stricmp(tline
->next
->text
, ".nolist"))
2376 tline
= tline
->next
;
2377 defining
->nolist
= TRUE
;
2379 mmac
= mmacros
[hash(defining
->name
)];
2382 if (!strcmp(mmac
->name
, defining
->name
) &&
2383 (mmac
->nparam_min
<= defining
->nparam_max
2385 && (defining
->nparam_min
<= mmac
->nparam_max
2389 "redefining multi-line macro `%s'",
2396 * Handle default parameters.
2398 if (tline
&& tline
->next
)
2400 defining
->dlist
= tline
->next
;
2402 count_mmac_params(defining
->dlist
, &defining
->ndefs
,
2403 &defining
->defaults
);
2407 defining
->dlist
= NULL
;
2408 defining
->defaults
= NULL
;
2410 defining
->expansion
= NULL
;
2411 free_tlist(origline
);
2418 error(ERR_NONFATAL
, "`%s': not defining a macro",
2422 k
= hash(defining
->name
);
2423 defining
->next
= mmacros
[k
];
2424 mmacros
[k
] = defining
;
2426 free_tlist(origline
);
2430 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
2431 tline
= tline
->next
;
2432 t
= expand_smacro(tline
->next
);
2434 free_tlist(origline
);
2437 tokval
.t_type
= TOKEN_INVALID
;
2439 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2445 "trailing garbage after expression ignored");
2446 if (!is_simple(evalresult
))
2448 error(ERR_NONFATAL
, "non-constant value given to `%%rotate'");
2452 while (mmac
&& !mmac
->name
) /* avoid mistaking %reps for macros */
2453 mmac
= mmac
->next_active
;
2456 "`%%rotate' invoked outside a macro call");
2457 mmac
->rotate
= mmac
->rotate
+ reloc_value(evalresult
);
2458 if (mmac
->rotate
< 0)
2459 mmac
->rotate
= mmac
->nparam
- (-mmac
->rotate
) % mmac
->nparam
;
2460 mmac
->rotate
%= mmac
->nparam
;
2465 tline
= tline
->next
;
2466 if (tline
->next
&& tline
->next
->type
== TOK_WHITESPACE
)
2467 tline
= tline
->next
;
2468 if (tline
->next
&& tline
->next
->type
== TOK_ID
&&
2469 !nasm_stricmp(tline
->next
->text
, ".nolist"))
2471 tline
= tline
->next
;
2474 t
= expand_smacro(tline
->next
);
2476 free_tlist(origline
);
2479 tokval
.t_type
= TOKEN_INVALID
;
2481 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2487 "trailing garbage after expression ignored");
2488 if (!is_simple(evalresult
))
2490 error(ERR_NONFATAL
, "non-constant value given to `%%rep'");
2493 tmp_defining
= defining
;
2494 defining
= nasm_malloc(sizeof(MMacro
));
2495 defining
->name
= NULL
; /* flags this macro as a %rep block */
2496 defining
->casesense
= 0;
2497 defining
->plus
= FALSE
;
2498 defining
->nolist
= nolist
;
2499 defining
->in_progress
= reloc_value(evalresult
) + 1;
2500 defining
->nparam_min
= defining
->nparam_max
= 0;
2501 defining
->defaults
= NULL
;
2502 defining
->dlist
= NULL
;
2503 defining
->expansion
= NULL
;
2504 defining
->next_active
= istk
->mstk
;
2505 defining
->rep_nest
= tmp_defining
;
2509 if (!defining
|| defining
->name
)
2511 error(ERR_NONFATAL
, "`%%endrep': no matching `%%rep'");
2516 * Now we have a "macro" defined - although it has no name
2517 * and we won't be entering it in the hash tables - we must
2518 * push a macro-end marker for it on to istk->expansion.
2519 * After that, it will take care of propagating itself (a
2520 * macro-end marker line for a macro which is really a %rep
2521 * block will cause the macro to be re-expanded, complete
2522 * with another macro-end marker to ensure the process
2523 * continues) until the whole expansion is forcibly removed
2524 * from istk->expansion by a %exitrep.
2526 l
= nasm_malloc(sizeof(Line
));
2527 l
->next
= istk
->expansion
;
2528 l
->finishes
= defining
;
2530 istk
->expansion
= l
;
2532 istk
->mstk
= defining
;
2534 list
->uplevel(defining
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
2535 tmp_defining
= defining
;
2536 defining
= defining
->rep_nest
;
2537 free_tlist(origline
);
2542 * We must search along istk->expansion until we hit a
2543 * macro-end marker for a macro with no name. Then we set
2544 * its `in_progress' flag to 0.
2546 for (l
= istk
->expansion
; l
; l
= l
->next
)
2547 if (l
->finishes
&& !l
->finishes
->name
)
2551 l
->finishes
->in_progress
= 0;
2553 error(ERR_NONFATAL
, "`%%exitrep' not within `%%rep' block");
2554 free_tlist(origline
);
2561 tline
= tline
->next
;
2563 tline
= expand_id(tline
);
2564 if (!tline
|| (tline
->type
!= TOK_ID
&&
2565 (tline
->type
!= TOK_PREPROC_ID
||
2566 tline
->text
[1] != '$')))
2569 "`%%%s%sdefine' expects a macro identifier",
2570 ((i
== PP_IDEFINE
|| i
== PP_IXDEFINE
) ? "i" : ""),
2571 ((i
== PP_XDEFINE
|| i
== PP_IXDEFINE
) ? "x" : ""));
2572 free_tlist(origline
);
2576 ctx
= get_ctx(tline
->text
, FALSE
);
2578 smhead
= &smacros
[hash(tline
->text
)];
2580 smhead
= &ctx
->localmac
;
2581 mname
= tline
->text
;
2583 param_start
= tline
= tline
->next
;
2586 /* Expand the macro definition now for %xdefine and %ixdefine */
2587 if ((i
== PP_XDEFINE
) || (i
== PP_IXDEFINE
))
2588 tline
= expand_smacro(tline
);
2590 if (tok_is_(tline
, "("))
2593 * This macro has parameters.
2596 tline
= tline
->next
;
2602 error(ERR_NONFATAL
, "parameter identifier expected");
2603 free_tlist(origline
);
2606 if (tline
->type
!= TOK_ID
)
2609 "`%s': parameter identifier expected",
2611 free_tlist(origline
);
2614 tline
->type
= TOK_SMAC_PARAM
+ nparam
++;
2615 tline
= tline
->next
;
2617 if (tok_is_(tline
, ","))
2619 tline
= tline
->next
;
2622 if (!tok_is_(tline
, ")"))
2625 "`)' expected to terminate macro template");
2626 free_tlist(origline
);
2632 tline
= tline
->next
;
2634 if (tok_type_(tline
, TOK_WHITESPACE
))
2635 last
= tline
, tline
= tline
->next
;
2641 if (t
->type
== TOK_ID
)
2643 for (tt
= param_start
; tt
; tt
= tt
->next
)
2644 if (tt
->type
>= TOK_SMAC_PARAM
&&
2645 !strcmp(tt
->text
, t
->text
))
2649 t
->next
= macro_start
;
2654 * Good. We now have a macro name, a parameter count, and a
2655 * token list (in reverse order) for an expansion. We ought
2656 * to be OK just to create an SMacro, store it, and let
2657 * free_tlist have the rest of the line (which we have
2658 * carefully re-terminated after chopping off the expansion
2661 if (smacro_defined(ctx
, mname
, nparam
, &smac
, i
== PP_DEFINE
))
2666 "single-line macro `%s' defined both with and"
2667 " without parameters", mname
);
2668 free_tlist(origline
);
2669 free_tlist(macro_start
);
2675 * We're redefining, so we have to take over an
2676 * existing SMacro structure. This means freeing
2677 * what was already in it.
2679 nasm_free(smac
->name
);
2680 free_tlist(smac
->expansion
);
2685 smac
= nasm_malloc(sizeof(SMacro
));
2686 smac
->next
= *smhead
;
2689 smac
->name
= nasm_strdup(mname
);
2690 smac
->casesense
= ((i
== PP_DEFINE
) || (i
== PP_XDEFINE
));
2691 smac
->nparam
= nparam
;
2692 smac
->expansion
= macro_start
;
2693 smac
->in_progress
= FALSE
;
2694 free_tlist(origline
);
2698 tline
= tline
->next
;
2700 tline
= expand_id(tline
);
2701 if (!tline
|| (tline
->type
!= TOK_ID
&&
2702 (tline
->type
!= TOK_PREPROC_ID
||
2703 tline
->text
[1] != '$')))
2705 error(ERR_NONFATAL
, "`%%undef' expects a macro identifier");
2706 free_tlist(origline
);
2712 "trailing garbage after macro name ignored");
2715 /* Find the context that symbol belongs to */
2716 ctx
= get_ctx(tline
->text
, FALSE
);
2718 smhead
= &smacros
[hash(tline
->text
)];
2720 smhead
= &ctx
->localmac
;
2722 mname
= tline
->text
;
2727 * We now have a macro name... go hunt for it.
2729 while (smacro_defined(ctx
, mname
, -1, &smac
, 1))
2731 /* Defined, so we need to find its predecessor and nuke it */
2733 for (s
= smhead
; *s
&& *s
!= smac
; s
= &(*s
)->next
);
2737 nasm_free(smac
->name
);
2738 free_tlist(smac
->expansion
);
2742 free_tlist(origline
);
2746 tline
= tline
->next
;
2748 tline
= expand_id(tline
);
2749 if (!tline
|| (tline
->type
!= TOK_ID
&&
2750 (tline
->type
!= TOK_PREPROC_ID
||
2751 tline
->text
[1] != '$')))
2754 "`%%strlen' expects a macro identifier as first parameter");
2755 free_tlist(origline
);
2758 ctx
= get_ctx(tline
->text
, FALSE
);
2760 smhead
= &smacros
[hash(tline
->text
)];
2762 smhead
= &ctx
->localmac
;
2763 mname
= tline
->text
;
2765 tline
= expand_smacro(tline
->next
);
2769 while (tok_type_(t
, TOK_WHITESPACE
))
2771 /* t should now point to the string */
2772 if (t
->type
!= TOK_STRING
)
2775 "`%%strlen` requires string as second parameter");
2777 free_tlist(origline
);
2781 macro_start
= nasm_malloc(sizeof(*macro_start
));
2782 macro_start
->next
= NULL
;
2783 make_tok_num(macro_start
, strlen(t
->text
) - 2);
2784 macro_start
->mac
= NULL
;
2787 * We now have a macro name, an implicit parameter count of
2788 * zero, and a numeric token to use as an expansion. Create
2789 * and store an SMacro.
2791 if (smacro_defined(ctx
, mname
, 0, &smac
, i
== PP_STRLEN
))
2795 "single-line macro `%s' defined both with and"
2796 " without parameters", mname
);
2800 * We're redefining, so we have to take over an
2801 * existing SMacro structure. This means freeing
2802 * what was already in it.
2804 nasm_free(smac
->name
);
2805 free_tlist(smac
->expansion
);
2810 smac
= nasm_malloc(sizeof(SMacro
));
2811 smac
->next
= *smhead
;
2814 smac
->name
= nasm_strdup(mname
);
2815 smac
->casesense
= (i
== PP_STRLEN
);
2817 smac
->expansion
= macro_start
;
2818 smac
->in_progress
= FALSE
;
2820 free_tlist(origline
);
2824 tline
= tline
->next
;
2826 tline
= expand_id(tline
);
2827 if (!tline
|| (tline
->type
!= TOK_ID
&&
2828 (tline
->type
!= TOK_PREPROC_ID
||
2829 tline
->text
[1] != '$')))
2832 "`%%substr' expects a macro identifier as first parameter");
2833 free_tlist(origline
);
2836 ctx
= get_ctx(tline
->text
, FALSE
);
2838 smhead
= &smacros
[hash(tline
->text
)];
2840 smhead
= &ctx
->localmac
;
2841 mname
= tline
->text
;
2843 tline
= expand_smacro(tline
->next
);
2847 while (tok_type_(t
, TOK_WHITESPACE
))
2850 /* t should now point to the string */
2851 if (t
->type
!= TOK_STRING
)
2854 "`%%substr` requires string as second parameter");
2856 free_tlist(origline
);
2862 tokval
.t_type
= TOKEN_INVALID
;
2864 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2868 free_tlist(origline
);
2871 if (!is_simple(evalresult
))
2873 error(ERR_NONFATAL
, "non-constant value given to `%%substr`");
2875 free_tlist(origline
);
2879 macro_start
= nasm_malloc(sizeof(*macro_start
));
2880 macro_start
->next
= NULL
;
2881 macro_start
->text
= nasm_strdup("'''");
2882 if (evalresult
->value
> 0
2883 && evalresult
->value
< strlen(t
->text
) - 1)
2885 macro_start
->text
[1] = t
->text
[evalresult
->value
];
2889 macro_start
->text
[2] = '\0';
2891 macro_start
->type
= TOK_STRING
;
2892 macro_start
->mac
= NULL
;
2895 * We now have a macro name, an implicit parameter count of
2896 * zero, and a numeric token to use as an expansion. Create
2897 * and store an SMacro.
2899 if (smacro_defined(ctx
, mname
, 0, &smac
, i
== PP_SUBSTR
))
2903 "single-line macro `%s' defined both with and"
2904 " without parameters", mname
);
2908 * We're redefining, so we have to take over an
2909 * existing SMacro structure. This means freeing
2910 * what was already in it.
2912 nasm_free(smac
->name
);
2913 free_tlist(smac
->expansion
);
2918 smac
= nasm_malloc(sizeof(SMacro
));
2919 smac
->next
= *smhead
;
2922 smac
->name
= nasm_strdup(mname
);
2923 smac
->casesense
= (i
== PP_SUBSTR
);
2925 smac
->expansion
= macro_start
;
2926 smac
->in_progress
= FALSE
;
2928 free_tlist(origline
);
2934 tline
= tline
->next
;
2936 tline
= expand_id(tline
);
2937 if (!tline
|| (tline
->type
!= TOK_ID
&&
2938 (tline
->type
!= TOK_PREPROC_ID
||
2939 tline
->text
[1] != '$')))
2942 "`%%%sassign' expects a macro identifier",
2943 (i
== PP_IASSIGN
? "i" : ""));
2944 free_tlist(origline
);
2947 ctx
= get_ctx(tline
->text
, FALSE
);
2949 smhead
= &smacros
[hash(tline
->text
)];
2951 smhead
= &ctx
->localmac
;
2952 mname
= tline
->text
;
2954 tline
= expand_smacro(tline
->next
);
2959 tokval
.t_type
= TOKEN_INVALID
;
2961 evaluate(ppscan
, tptr
, &tokval
, NULL
, pass
, error
, NULL
);
2965 free_tlist(origline
);
2971 "trailing garbage after expression ignored");
2973 if (!is_simple(evalresult
))
2976 "non-constant value given to `%%%sassign'",
2977 (i
== PP_IASSIGN
? "i" : ""));
2978 free_tlist(origline
);
2982 macro_start
= nasm_malloc(sizeof(*macro_start
));
2983 macro_start
->next
= NULL
;
2984 make_tok_num(macro_start
, reloc_value(evalresult
));
2985 macro_start
->mac
= NULL
;
2988 * We now have a macro name, an implicit parameter count of
2989 * zero, and a numeric token to use as an expansion. Create
2990 * and store an SMacro.
2992 if (smacro_defined(ctx
, mname
, 0, &smac
, i
== PP_ASSIGN
))
2996 "single-line macro `%s' defined both with and"
2997 " without parameters", mname
);
3001 * We're redefining, so we have to take over an
3002 * existing SMacro structure. This means freeing
3003 * what was already in it.
3005 nasm_free(smac
->name
);
3006 free_tlist(smac
->expansion
);
3011 smac
= nasm_malloc(sizeof(SMacro
));
3012 smac
->next
= *smhead
;
3015 smac
->name
= nasm_strdup(mname
);
3016 smac
->casesense
= (i
== PP_ASSIGN
);
3018 smac
->expansion
= macro_start
;
3019 smac
->in_progress
= FALSE
;
3020 free_tlist(origline
);
3025 * Syntax is `%line nnn[+mmm] [filename]'
3027 tline
= tline
->next
;
3029 if (!tok_type_(tline
, TOK_NUMBER
))
3031 error(ERR_NONFATAL
, "`%%line' expects line number");
3032 free_tlist(origline
);
3035 k
= readnum(tline
->text
, &j
);
3037 tline
= tline
->next
;
3038 if (tok_is_(tline
, "+"))
3040 tline
= tline
->next
;
3041 if (!tok_type_(tline
, TOK_NUMBER
))
3043 error(ERR_NONFATAL
, "`%%line' expects line increment");
3044 free_tlist(origline
);
3047 m
= readnum(tline
->text
, &j
);
3048 tline
= tline
->next
;
3055 nasm_free(src_set_fname(detoken(tline
, FALSE
)));
3057 free_tlist(origline
);
3062 "preprocessor directive `%s' not yet implemented",
3070 * Ensure that a macro parameter contains a condition code and
3071 * nothing else. Return the condition code index if so, or -1
3081 if (t
->type
!= TOK_ID
)
3085 if (tt
&& (tt
->type
!= TOK_OTHER
|| strcmp(tt
->text
, ",")))
3089 j
= sizeof(conditions
) / sizeof(*conditions
);
3093 m
= nasm_stricmp(t
->text
, conditions
[k
]);
3113 * Expand MMacro-local things: parameter references (%0, %n, %+n,
3114 * %-n) and MMacro-local identifiers (%%foo).
3117 expand_mmac_params(Token
* tline
)
3119 Token
*t
, *tt
, **tail
, *thead
;
3126 if (tline
->type
== TOK_PREPROC_ID
&&
3127 (((tline
->text
[1] == '+' || tline
->text
[1] == '-')
3128 && tline
->text
[2]) || tline
->text
[1] == '%'
3129 || (tline
->text
[1] >= '0' && tline
->text
[1] <= '9')))
3132 int type
= 0, cc
; /* type = 0 to placate optimisers */
3138 tline
= tline
->next
;
3141 while (mac
&& !mac
->name
) /* avoid mistaking %reps for macros */
3142 mac
= mac
->next_active
;
3144 error(ERR_NONFATAL
, "`%s': not in a macro call", t
->text
);
3149 * We have to make a substitution of one of the
3150 * forms %1, %-1, %+1, %%foo, %0.
3154 sprintf(tmpbuf
, "%d", mac
->nparam
);
3155 text
= nasm_strdup(tmpbuf
);
3159 sprintf(tmpbuf
, "..@%lu.", mac
->unique
);
3160 text
= nasm_strcat(tmpbuf
, t
->text
+ 2);
3163 n
= atoi(t
->text
+ 2) - 1;
3164 if (n
>= mac
->nparam
)
3168 if (mac
->nparam
> 1)
3169 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3170 tt
= mac
->params
[n
];
3176 "macro parameter %d is not a condition code",
3183 if (inverse_ccs
[cc
] == -1)
3186 "condition code `%s' is not invertible",
3192 nasm_strdup(conditions
[inverse_ccs
3197 n
= atoi(t
->text
+ 2) - 1;
3198 if (n
>= mac
->nparam
)
3202 if (mac
->nparam
> 1)
3203 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3204 tt
= mac
->params
[n
];
3210 "macro parameter %d is not a condition code",
3217 text
= nasm_strdup(conditions
[cc
]);
3221 n
= atoi(t
->text
+ 1) - 1;
3222 if (n
>= mac
->nparam
)
3226 if (mac
->nparam
> 1)
3227 n
= (n
+ mac
->rotate
) % mac
->nparam
;
3228 tt
= mac
->params
[n
];
3232 for (i
= 0; i
< mac
->paramlen
[n
]; i
++)
3235 new_Token(NULL
, tt
->type
, tt
->text
,
3237 tail
= &(*tail
)->next
;
3241 text
= NULL
; /* we've done it here */
3262 tline
= tline
->next
;
3269 for (; t
&& (tt
= t
->next
) != NULL
; t
= t
->next
)
3272 case TOK_WHITESPACE
:
3273 if (tt
->type
== TOK_WHITESPACE
)
3275 t
->next
= delete_Token(tt
);
3279 if (tt
->type
== TOK_ID
|| tt
->type
== TOK_NUMBER
)
3281 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3284 t
->next
= delete_Token(tt
);
3288 if (tt
->type
== TOK_NUMBER
)
3290 char *tmp
= nasm_strcat(t
->text
, tt
->text
);
3293 t
->next
= delete_Token(tt
);
3302 * Expand all single-line macro calls made in the given line.
3303 * Return the expanded version of the line. The original is deemed
3304 * to be destroyed in the process. (In reality we'll just move
3305 * Tokens from input to output a lot of the time, rather than
3306 * actually bothering to destroy and replicate.)
3309 expand_smacro(Token
* tline
)
3311 Token
*t
, *tt
, *mstart
, **tail
, *thead
;
3312 SMacro
*head
= NULL
, *m
;
3315 int nparam
, sparam
, brackets
, rescan
;
3316 Token
*org_tline
= tline
;
3321 * Trick: we should avoid changing the start token pointer since it can
3322 * be contained in "next" field of other token. Because of this
3323 * we allocate a copy of first token and work with it; at the end of
3324 * routine we copy it back
3329 new_Token(org_tline
->next
, org_tline
->type
, org_tline
->text
,
3331 tline
->mac
= org_tline
->mac
;
3332 nasm_free(org_tline
->text
);
3333 org_tline
->text
= NULL
;
3341 { /* main token loop */
3342 if ((mname
= tline
->text
))
3344 /* if this token is a local macro, look in local context */
3345 if (tline
->type
== TOK_ID
|| tline
->type
== TOK_PREPROC_ID
)
3346 ctx
= get_ctx(mname
, TRUE
);
3350 head
= smacros
[hash(mname
)];
3352 head
= ctx
->localmac
;
3354 * We've hit an identifier. As in is_mmacro below, we first
3355 * check whether the identifier is a single-line macro at
3356 * all, then think about checking for parameters if
3359 for (m
= head
; m
; m
= m
->next
)
3360 if (!mstrcmp(m
->name
, mname
, m
->casesense
))
3370 * Simple case: the macro is parameterless. Discard the
3371 * one token that the macro call took, and push the
3372 * expansion back on the to-do stack.
3376 if (!strcmp("__FILE__", m
->name
))
3379 src_get(&num
, &(tline
->text
));
3380 nasm_quote(&(tline
->text
));
3381 tline
->type
= TOK_STRING
;
3384 if (!strcmp("__LINE__", m
->name
))
3386 nasm_free(tline
->text
);
3387 make_tok_num(tline
, src_get_linnum());
3390 tline
= delete_Token(tline
);
3397 * Complicated case: at least one macro with this name
3398 * exists and takes parameters. We must find the
3399 * parameters in the call, count them, find the SMacro
3400 * that corresponds to that form of the macro call, and
3401 * substitute for the parameters when we expand. What a
3404 tline
= tline
->next
;
3406 if (!tok_is_(tline
, "("))
3409 * This macro wasn't called with parameters: ignore
3410 * the call. (Behaviour borrowed from gnu cpp.)
3421 tline
= tline
->next
;
3422 sparam
= PARAM_DELTA
;
3423 params
= nasm_malloc(sparam
* sizeof(Token
*));
3425 paramsize
= nasm_malloc(sparam
* sizeof(int));
3427 for (;; tline
= tline
->next
)
3428 { /* parameter loop */
3432 "macro call expects terminating `)'");
3435 if (tline
->type
== TOK_WHITESPACE
3438 if (paramsize
[nparam
])
3441 params
[nparam
] = tline
->next
;
3442 continue; /* parameter loop */
3444 if (tline
->type
== TOK_OTHER
3445 && tline
->text
[1] == 0)
3447 char ch
= tline
->text
[0];
3448 if (ch
== ',' && !paren
&& brackets
<= 0)
3450 if (++nparam
>= sparam
)
3452 sparam
+= PARAM_DELTA
;
3453 params
= nasm_realloc(params
,
3454 sparam
* sizeof(Token
*));
3455 paramsize
= nasm_realloc(paramsize
,
3456 sparam
* sizeof(int));
3458 params
[nparam
] = tline
->next
;
3459 paramsize
[nparam
] = 0;
3461 continue; /* parameter loop */
3464 (brackets
> 0 || (brackets
== 0 &&
3465 !paramsize
[nparam
])))
3469 params
[nparam
] = tline
->next
;
3470 continue; /* parameter loop */
3473 if (ch
== '}' && brackets
> 0)
3474 if (--brackets
== 0)
3477 continue; /* parameter loop */
3479 if (ch
== '(' && !brackets
)
3481 if (ch
== ')' && brackets
<= 0)
3488 error(ERR_NONFATAL
, "braces do not "
3489 "enclose all of macro parameter");
3491 paramsize
[nparam
] += white
+ 1;
3493 } /* parameter loop */
3495 while (m
&& (m
->nparam
!= nparam
||
3496 mstrcmp(m
->name
, mname
,
3500 error(ERR_WARNING
| ERR_WARN_MNP
,
3501 "macro `%s' exists, "
3502 "but not taking %d parameters",
3503 mstart
->text
, nparam
);
3506 if (m
&& m
->in_progress
)
3508 if (!m
) /* in progess or didn't find '(' or wrong nparam */
3511 * Design question: should we handle !tline, which
3512 * indicates missing ')' here, or expand those
3513 * macros anyway, which requires the (t) test a few
3517 nasm_free(paramsize
);
3523 * Expand the macro: we are placed on the last token of the
3524 * call, so that we can easily split the call from the
3525 * following tokens. We also start by pushing an SMAC_END
3526 * token for the cycle removal.
3534 tt
= new_Token(tline
, TOK_SMAC_END
, NULL
, 0);
3536 m
->in_progress
= TRUE
;
3538 for (t
= m
->expansion
; t
; t
= t
->next
)
3540 if (t
->type
>= TOK_SMAC_PARAM
)
3542 Token
*pcopy
= tline
, **ptail
= &pcopy
;
3546 ttt
= params
[t
->type
- TOK_SMAC_PARAM
];
3547 for (i
= paramsize
[t
->type
- TOK_SMAC_PARAM
];
3551 new_Token(tline
, ttt
->type
, ttt
->text
,
3560 tt
= new_Token(tline
, t
->type
, t
->text
, 0);
3566 * Having done that, get rid of the macro call, and clean
3567 * up the parameters.
3570 nasm_free(paramsize
);
3572 continue; /* main token loop */
3577 if (tline
->type
== TOK_SMAC_END
)
3579 tline
->mac
->in_progress
= FALSE
;
3580 tline
= delete_Token(tline
);
3585 tline
= tline
->next
;
3593 * Now scan the entire line and look for successive TOK_IDs that resulted
3594 * after expansion (they can't be produced by tokenise()). The successive
3595 * TOK_IDs should be concatenated.
3596 * Also we look for %+ tokens and concatenate the tokens before and after
3597 * them (without white spaces in between).
3603 while (t
&& t
->type
!= TOK_ID
&& t
->type
!= TOK_PREPROC_ID
)
3607 if (t
->next
->type
== TOK_ID
||
3608 t
->next
->type
== TOK_PREPROC_ID
||
3609 t
->next
->type
== TOK_NUMBER
)
3611 char *p
= nasm_strcat(t
->text
, t
->next
->text
);
3613 t
->next
= delete_Token(t
->next
);
3617 else if (t
->next
->type
== TOK_WHITESPACE
&& t
->next
->next
&&
3618 t
->next
->next
->type
== TOK_PREPROC_ID
&&
3619 strcmp(t
->next
->next
->text
, "%+") == 0)
3621 /* free the next whitespace, the %+ token and next whitespace */
3623 for (i
= 1; i
<= 3; i
++)
3625 if (!t
->next
|| (i
!= 2 && t
->next
->type
!= TOK_WHITESPACE
))
3627 t
->next
= delete_Token(t
->next
);
3633 /* If we concatenaded something, re-scan the line for macros */
3644 *org_tline
= *thead
;
3645 /* since we just gave text to org_line, don't free it */
3647 delete_Token(thead
);
3651 /* the expression expanded to empty line;
3652 we can't return NULL for some reasons
3653 we just set the line to a single WHITESPACE token. */
3654 memset(org_tline
, 0, sizeof(*org_tline
));
3655 org_tline
->text
= NULL
;
3656 org_tline
->type
= TOK_WHITESPACE
;
3665 * Similar to expand_smacro but used exclusively with macro identifiers
3666 * right before they are fetched in. The reason is that there can be
3667 * identifiers consisting of several subparts. We consider that if there
3668 * are more than one element forming the name, user wants a expansion,
3669 * otherwise it will be left as-is. Example:
3673 * the identifier %$abc will be left as-is so that the handler for %define
3674 * will suck it and define the corresponding value. Other case:
3676 * %define _%$abc cde
3678 * In this case user wants name to be expanded *before* %define starts
3679 * working, so we'll expand %$abc into something (if it has a value;
3680 * otherwise it will be left as-is) then concatenate all successive
3684 expand_id(Token
* tline
)
3686 Token
*cur
, *oldnext
= NULL
;
3688 if (!tline
|| !tline
->next
)
3693 (cur
->next
->type
== TOK_ID
||
3694 cur
->next
->type
== TOK_PREPROC_ID
|| cur
->next
->type
== TOK_NUMBER
))
3697 /* If identifier consists of just one token, don't expand */
3703 oldnext
= cur
->next
; /* Detach the tail past identifier */
3704 cur
->next
= NULL
; /* so that expand_smacro stops here */
3707 tline
= expand_smacro(tline
);
3711 /* expand_smacro possibly changhed tline; re-scan for EOL */
3713 while (cur
&& cur
->next
)
3716 cur
->next
= oldnext
;
3723 * Determine whether the given line constitutes a multi-line macro
3724 * call, and return the MMacro structure called if so. Doesn't have
3725 * to check for an initial label - that's taken care of in
3726 * expand_mmacro - but must check numbers of parameters. Guaranteed
3727 * to be called with tline->type == TOK_ID, so the putative macro
3728 * name is easy to find.
3731 is_mmacro(Token
* tline
, Token
*** params_array
)
3737 head
= mmacros
[hash(tline
->text
)];
3740 * Efficiency: first we see if any macro exists with the given
3741 * name. If not, we can return NULL immediately. _Then_ we
3742 * count the parameters, and then we look further along the
3743 * list if necessary to find the proper MMacro.
3745 for (m
= head
; m
; m
= m
->next
)
3746 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
3752 * OK, we have a potential macro. Count and demarcate the
3755 count_mmac_params(tline
->next
, &nparam
, ¶ms
);
3758 * So we know how many parameters we've got. Find the MMacro
3759 * structure that handles this number.
3763 if (m
->nparam_min
<= nparam
&& (m
->plus
|| nparam
<= m
->nparam_max
))
3766 * This one is right. Just check if cycle removal
3767 * prohibits us using it before we actually celebrate...
3773 "self-reference in multi-line macro `%s'", m
->name
);
3779 * It's right, and we can use it. Add its default
3780 * parameters to the end of our list if necessary.
3782 if (m
->defaults
&& nparam
< m
->nparam_min
+ m
->ndefs
)
3785 nasm_realloc(params
,
3786 ((m
->nparam_min
+ m
->ndefs
+ 1) * sizeof(*params
)));
3787 while (nparam
< m
->nparam_min
+ m
->ndefs
)
3789 params
[nparam
] = m
->defaults
[nparam
- m
->nparam_min
];
3794 * If we've gone over the maximum parameter count (and
3795 * we're in Plus mode), ignore parameters beyond
3798 if (m
->plus
&& nparam
> m
->nparam_max
)
3799 nparam
= m
->nparam_max
;
3801 * Then terminate the parameter list, and leave.
3804 { /* need this special case */
3805 params
= nasm_malloc(sizeof(*params
));
3808 params
[nparam
] = NULL
;
3809 *params_array
= params
;
3813 * This one wasn't right: look for the next one with the
3816 for (m
= m
->next
; m
; m
= m
->next
)
3817 if (!mstrcmp(m
->name
, tline
->text
, m
->casesense
))
3822 * After all that, we didn't find one with the right number of
3823 * parameters. Issue a warning, and fail to expand the macro.
3825 error(ERR_WARNING
| ERR_WARN_MNP
,
3826 "macro `%s' exists, but not taking %d parameters",
3827 tline
->text
, nparam
);
3833 * Expand the multi-line macro call made by the given line, if
3834 * there is one to be expanded. If there is, push the expansion on
3835 * istk->expansion and return 1. Otherwise return 0.
3838 expand_mmacro(Token
* tline
)
3840 Token
*startline
= tline
;
3841 Token
*label
= NULL
;
3842 int dont_prepend
= 0;
3843 Token
**params
, *t
, *tt
;
3846 int i
, nparam
, *paramlen
;
3850 /* if (!tok_type_(t, TOK_ID)) Lino 02/25/02 */
3851 if (!tok_type_(t
, TOK_ID
) && !tok_type_(t
, TOK_PREPROC_ID
))
3853 m
= is_mmacro(t
, ¶ms
);
3858 * We have an id which isn't a macro call. We'll assume
3859 * it might be a label; we'll also check to see if a
3860 * colon follows it. Then, if there's another id after
3861 * that lot, we'll check it again for macro-hood.
3865 if (tok_type_(t
, TOK_WHITESPACE
))
3866 last
= t
, t
= t
->next
;
3867 if (tok_is_(t
, ":"))
3870 last
= t
, t
= t
->next
;
3871 if (tok_type_(t
, TOK_WHITESPACE
))
3872 last
= t
, t
= t
->next
;
3874 if (!tok_type_(t
, TOK_ID
) || (m
= is_mmacro(t
, ¶ms
)) == NULL
)
3881 * Fix up the parameters: this involves stripping leading and
3882 * trailing whitespace, then stripping braces if they are
3885 for (nparam
= 0; params
[nparam
]; nparam
++)
3887 paramlen
= nparam
? nasm_malloc(nparam
* sizeof(*paramlen
)) : NULL
;
3889 for (i
= 0; params
[i
]; i
++)
3892 int comma
= (!m
->plus
|| i
< nparam
- 1);
3896 if (tok_is_(t
, "{"))
3897 t
= t
->next
, brace
= TRUE
, comma
= FALSE
;
3902 if (comma
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, ","))
3903 break; /* ... because we have hit a comma */
3904 if (comma
&& t
->type
== TOK_WHITESPACE
&& tok_is_(t
->next
, ","))
3905 break; /* ... or a space then a comma */
3906 if (brace
&& t
->type
== TOK_OTHER
&& !strcmp(t
->text
, "}"))
3907 break; /* ... or a brace */
3914 * OK, we have a MMacro structure together with a set of
3915 * parameters. We must now go through the expansion and push
3916 * copies of each Line on to istk->expansion. Substitution of
3917 * parameter tokens and macro-local tokens doesn't get done
3918 * until the single-line macro substitution process; this is
3919 * because delaying them allows us to change the semantics
3920 * later through %rotate.
3922 * First, push an end marker on to istk->expansion, mark this
3923 * macro as in progress, and set up its invocation-specific
3926 ll
= nasm_malloc(sizeof(Line
));
3927 ll
->next
= istk
->expansion
;
3930 istk
->expansion
= ll
;
3932 m
->in_progress
= TRUE
;
3937 m
->paramlen
= paramlen
;
3938 m
->unique
= unique
++;
3941 m
->next_active
= istk
->mstk
;
3944 for (l
= m
->expansion
; l
; l
= l
->next
)
3948 ll
= nasm_malloc(sizeof(Line
));
3949 ll
->finishes
= NULL
;
3950 ll
->next
= istk
->expansion
;
3951 istk
->expansion
= ll
;
3954 for (t
= l
->first
; t
; t
= t
->next
)
3957 if (t
->type
== TOK_PREPROC_ID
&&
3958 t
->text
[1] == '0' && t
->text
[2] == '0')
3965 tt
= *tail
= new_Token(NULL
, x
->type
, x
->text
, 0);
3972 * If we had a label, push it on as the first line of
3973 * the macro expansion.
3977 if (dont_prepend
< 0)
3978 free_tlist(startline
);
3981 ll
= nasm_malloc(sizeof(Line
));
3982 ll
->finishes
= NULL
;
3983 ll
->next
= istk
->expansion
;
3984 istk
->expansion
= ll
;
3985 ll
->first
= startline
;
3989 label
= label
->next
;
3990 label
->next
= tt
= new_Token(NULL
, TOK_OTHER
, ":", 0);
3995 list
->uplevel(m
->nolist
? LIST_MACRO_NOLIST
: LIST_MACRO
);
4001 * Since preprocessor always operate only on the line that didn't
4002 * arrived yet, we should always use ERR_OFFBY1. Also since user
4003 * won't want to see same error twice (preprocessing is done once
4004 * per pass) we will want to show errors only during pass one.
4007 error(int severity
, char *fmt
, ...)
4012 /* If we're in a dead branch of IF or something like it, ignore the error */
4013 if (istk
&& istk
->conds
&& !emitting(istk
->conds
->state
))
4017 vsprintf(buff
, fmt
, arg
);
4020 if (istk
&& istk
->mstk
&& istk
->mstk
->name
)
4021 _error(severity
| ERR_PASS1
, "(%s:%d) %s", istk
->mstk
->name
,
4022 istk
->mstk
->lineno
, buff
);
4024 _error(severity
| ERR_PASS1
, "%s", buff
);
4028 pp_reset(char *file
, int apass
, efunc errfunc
, evalfunc eval
,
4035 istk
= nasm_malloc(sizeof(Include
));
4038 istk
->expansion
= NULL
;
4040 istk
->fp
= fopen(file
, "r");
4042 src_set_fname(nasm_strdup(file
));
4046 error(ERR_FATAL
| ERR_NOFILE
, "unable to open input file `%s'", file
);
4048 for (h
= 0; h
< NHASH
; h
++)
4054 if (tasm_compatible_mode
) {
4057 stdmacpos
= &stdmac
[TASM_MACRO_COUNT
];
4059 any_extrastdmac
= (extrastdmac
!= NULL
);
4074 * Fetch a tokenised line, either from the macro-expansion
4075 * buffer or from the input file.
4078 while (istk
->expansion
&& istk
->expansion
->finishes
)
4080 Line
*l
= istk
->expansion
;
4081 if (!l
->finishes
->name
&& l
->finishes
->in_progress
> 1)
4086 * This is a macro-end marker for a macro with no
4087 * name, which means it's not really a macro at all
4088 * but a %rep block, and the `in_progress' field is
4089 * more than 1, meaning that we still need to
4090 * repeat. (1 means the natural last repetition; 0
4091 * means termination by %exitrep.) We have
4092 * therefore expanded up to the %endrep, and must
4093 * push the whole block on to the expansion buffer
4094 * again. We don't bother to remove the macro-end
4095 * marker: we'd only have to generate another one
4098 l
->finishes
->in_progress
--;
4099 for (l
= l
->finishes
->expansion
; l
; l
= l
->next
)
4101 Token
*t
, *tt
, **tail
;
4103 ll
= nasm_malloc(sizeof(Line
));
4104 ll
->next
= istk
->expansion
;
4105 ll
->finishes
= NULL
;
4109 for (t
= l
->first
; t
; t
= t
->next
)
4111 if (t
->text
|| t
->type
== TOK_WHITESPACE
)
4113 tt
= *tail
= new_Token(NULL
, t
->type
, t
->text
, 0);
4118 istk
->expansion
= ll
;
4124 * Check whether a `%rep' was started and not ended
4125 * within this macro expansion. This can happen and
4126 * should be detected. It's a fatal error because
4127 * I'm too confused to work out how to recover
4133 error(ERR_PANIC
, "defining with name in expansion");
4134 else if (istk
->mstk
->name
)
4135 error(ERR_FATAL
, "`%%rep' without `%%endrep' within"
4136 " expansion of macro `%s'", istk
->mstk
->name
);
4140 * FIXME: investigate the relationship at this point between
4141 * istk->mstk and l->finishes
4144 MMacro
*m
= istk
->mstk
;
4145 istk
->mstk
= m
->next_active
;
4149 * This was a real macro call, not a %rep, and
4150 * therefore the parameter information needs to
4153 nasm_free(m
->params
);
4154 free_tlist(m
->iline
);
4155 nasm_free(m
->paramlen
);
4156 l
->finishes
->in_progress
= FALSE
;
4161 istk
->expansion
= l
->next
;
4163 list
->downlevel(LIST_MACRO
);
4167 { /* until we get a line we can use */
4169 if (istk
->expansion
)
4170 { /* from a macro expansion */
4172 Line
*l
= istk
->expansion
;
4174 istk
->mstk
->lineno
++;
4176 istk
->expansion
= l
->next
;
4178 p
= detoken(tline
, FALSE
);
4179 list
->line(LIST_MACRO
, p
);
4185 { /* from the current input file */
4186 line
= prepreproc(line
);
4187 tline
= tokenise(line
);
4192 * The current file has ended; work down the istk
4198 error(ERR_FATAL
, "expected `%%endif' before end of file");
4200 list
->downlevel(LIST_INCLUDE
);
4201 src_set_linnum(i
->lineno
);
4202 nasm_free(src_set_fname(i
->fname
));
4210 * We must expand MMacro parameters and MMacro-local labels
4211 * _before_ we plunge into directive processing, to cope
4212 * with things like `%define something %1' such as STRUC
4213 * uses. Unless we're _defining_ a MMacro, in which case
4214 * those tokens should be left alone to go into the
4215 * definition; and unless we're in a non-emitting
4216 * condition, in which case we don't want to meddle with
4219 if (!defining
&& !(istk
->conds
&& !emitting(istk
->conds
->state
)))
4220 tline
= expand_mmac_params(tline
);
4223 * Check the line to see if it's a preprocessor directive.
4225 if (do_directive(tline
) & 1)
4232 * We're defining a multi-line macro. We emit nothing
4234 * shove the tokenised line on to the macro definition.
4236 Line
*l
= nasm_malloc(sizeof(Line
));
4237 l
->next
= defining
->expansion
;
4239 l
->finishes
= FALSE
;
4240 defining
->expansion
= l
;
4243 else if (istk
->conds
&& !emitting(istk
->conds
->state
))
4246 * We're in a non-emitting branch of a condition block.
4247 * Emit nothing at all, not even a blank line: when we
4248 * emerge from the condition we'll give a line-number
4249 * directive so we keep our place correctly.
4254 else if (istk
->mstk
&& !istk
->mstk
->in_progress
)
4257 * We're in a %rep block which has been terminated, so
4258 * we're walking through to the %endrep without
4259 * emitting anything. Emit nothing at all, not even a
4260 * blank line: when we emerge from the %rep block we'll
4261 * give a line-number directive so we keep our place
4269 tline
= expand_smacro(tline
);
4270 if (!expand_mmacro(tline
))
4273 * De-tokenise the line again, and emit it.
4275 line
= detoken(tline
, TRUE
);
4281 continue; /* expand_mmacro calls free_tlist */
4290 pp_cleanup(int pass
)
4296 error(ERR_NONFATAL
, "end of file while still defining macro `%s'",
4298 free_mmacro(defining
);
4302 for (h
= 0; h
< NHASH
; h
++)
4306 MMacro
*m
= mmacros
[h
];
4307 mmacros
[h
] = mmacros
[h
]->next
;
4312 SMacro
*s
= smacros
[h
];
4313 smacros
[h
] = smacros
[h
]->next
;
4315 free_tlist(s
->expansion
);
4324 nasm_free(i
->fname
);
4337 pp_include_path(char *path
)
4341 i
= nasm_malloc(sizeof(IncPath
));
4342 i
->path
= nasm_strdup(path
);
4348 pp_pre_include(char *fname
)
4350 Token
*inc
, *space
, *name
;
4353 name
= new_Token(NULL
, TOK_INTERNAL_STRING
, fname
, 0);
4354 space
= new_Token(name
, TOK_WHITESPACE
, NULL
, 0);
4355 inc
= new_Token(space
, TOK_PREPROC_ID
, "%include", 0);
4357 l
= nasm_malloc(sizeof(Line
));
4360 l
->finishes
= FALSE
;
4365 pp_pre_define(char *definition
)
4371 equals
= strchr(definition
, '=');
4372 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4373 def
= new_Token(space
, TOK_PREPROC_ID
, "%define", 0);
4376 space
->next
= tokenise(definition
);
4380 l
= nasm_malloc(sizeof(Line
));
4383 l
->finishes
= FALSE
;
4388 pp_pre_undefine(char *definition
)
4393 space
= new_Token(NULL
, TOK_WHITESPACE
, NULL
, 0);
4394 def
= new_Token(space
, TOK_PREPROC_ID
, "%undef", 0);
4396 l
= nasm_malloc(sizeof(Line
));
4399 l
->finishes
= FALSE
;
4404 pp_extra_stdmac(char **macros
)
4406 extrastdmac
= macros
;
4410 make_tok_num(Token
* tok
, long val
)
4413 sprintf(numbuf
, "%ld", val
);
4414 tok
->text
= nasm_strdup(numbuf
);
4415 tok
->type
= TOK_NUMBER
;