1 /* GNU m4 -- A simple macro processor
3 Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994, 2006, 2007, 2008 Free
4 Software Foundation, Inc.
6 This file is part of GNU M4.
8 GNU M4 is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU M4 is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
22 /* This file contains the functions, that performs the basic argument
23 parsing and macro expansion. */
28 # define DEBUG_MACRO 0
29 #endif /* DEBUG_MACRO */
31 /* Opaque structure describing all arguments to a macro, including the
32 macro name at index 0. The lifetime of argv0 is only guaranteed
33 within a call to expand_macro, whereas the lifetime of the array
34 members is guaranteed as long as the input engine can parse text
35 with a reference to $@. */
36 struct macro_arguments
38 /* Number of arguments owned by this object, may be larger than
39 arraylen since the array can refer to multiple arguments via a
40 single $@ reference. */
42 /* False unless the macro expansion refers to $@; determines whether
43 this object can be freed immediately at the end of expand_macro,
44 or must wait until all recursion has completed. */
45 bool_bitfield inuse
: 1;
46 /* False if all arguments are just text or func, true if this argv
47 refers to another one. */
48 bool_bitfield wrapper
: 1;
49 /* False if all arguments belong to this argv, true if some of them
50 include references to another. */
51 bool_bitfield has_ref
: 1;
52 /* True to flatten builtins contained in references. */
53 bool_bitfield flatten
: 1;
54 /* True if any token contains builtins. */
55 bool_bitfield has_func
: 1;
56 const char *argv0
; /* The macro name being expanded. */
57 size_t argv0_len
; /* Length of argv0. */
58 /* The value of quote_age used when parsing all arguments in this
59 object, or 0 if quote_age changed during parsing or if any of the
60 arguments might contain content that can affect rescan. */
61 unsigned int quote_age
;
62 int level
; /* Which obstack owns this argv. */
63 unsigned int arraylen
; /* True length of allocated elements in array. */
64 /* Used as a variable-length array, storing information about each
66 token_data
*array
[FLEXIBLE_ARRAY_MEMBER
];
69 /* Internal struct to maintain list of argument stacks. Within a
70 recursion level, consecutive macros can share a stack, but distinct
71 recursion levels need different stacks since the nested macro is
72 interrupting the argument collection of the outer level. Note that
73 a reference can live as long as the expansion containing the
74 reference can participate as an argument in a future macro call.
76 Therefore, we implement a reference counter for each expansion
77 level, tracking how many references exist into the obstack, as well
78 as associate a level with each reference. Of course, expand_macro
79 is actively using argv, so it increments the refcount on entry and
80 decrements it on exit. Additionally, any time the input engine is
81 handed a reference that it does not inline, it increases the
82 refcount in push_token, then decreases it in pop_input once the
83 reference has been rescanned. Finally, when the input engine hands
84 a reference back to expand_argument, the refcount increases, which
85 is then cleaned up at the end of expand_macro.
87 For a running example, consider this input:
89 define(a,A)define(b,`a(`$1')')define(c,$*)dnl
90 define(x,`a(1)`'c($@')define(y,`$@)')dnl
91 x(a(`b')``a'')y(`b')(`a')
94 Assuming all arguments are large enough to exceed the inlining
95 thresholds of the input engine, the interesting sequence of events
98 stacks[0] refs stacks[1] refs
99 after second dnl ends: `' 0 `' 0
100 expand_macro for x, level 0: `' 1 `' 0
101 expand_macro for a, level 1: `' 1 `' 1
102 after collect_arguments for a: `' 1 `b' 1
103 push `A' to input stack: `' 1 `b' 1
104 exit expand_macro for a: `' 1 `' 0
105 after collect_arguments for x: `A`a'' 1 `' 0
106 push `a(1)`'c(' to input stack: `A`a'' 1 `' 0
107 push_token saves $@(x) ref: `A`a'' 2 `' 0
108 exit expand_macro for x: `A`a'' 1 `' 0
109 expand_macro for a, level 0: `A`a'' 2 `' 0
110 after collect_arguments for a: `A`a''`1' 2 `' 0
111 push `A' to input stack: `A`a''`1' 2 `' 0
112 exit expand_macro for a: `A`a'' 1 `' 0
113 output `A': `A`a'' 1 `' 0
114 expand_macro for c, level 0: `A`a'' 2 `' 0
115 expand_argument gets $@(x) ref: `A`a''`$@(x)' 3 `' 0
116 pop_input ends $@(x) ref: `A`a''`$@(x)' 2 `' 0
117 expand_macro for y, level 1: `A`a''`$@(x)' 2 `' 1
118 after collect_arguments for y: `A`a''`$@(x)' 2 `b' 1
119 push_token saves $@(y) ref: `A`a''`$@(x)' 2 `b' 2
120 push `)' to input stack: `A`a''`$@(x)' 2 `b' 2
121 exit expand_macro for y: `A`a''`$@(x)' 2 `b' 1
122 expand_argument gets $@(y) ref: `A`a''`$@(x)$@(y)' 2 `b' 2
123 pop_input ends $@(y) ref: `A`a''`$@(x)$@(y)' 2 `b' 1
124 after collect_arguments for c: `A`a''`$@(x)$@(y)' 2 `b' 1
125 push_token saves $*(c) ref: `A`a''`$@(x)$@(y)' 3 `b' 2
126 expand_macro frees $@(x) ref: `A`a''`$@(x)$@(y)' 2 `b' 2
127 expand_macro frees $@(y) ref: `A`a''`$@(x)$@(y)' 2 `b' 1
128 exit expand_macro for c: `A`a''`$@(x)$@(y)' 1 `b' 1
129 output `Aa': `A`a''`$@(x)$@(y)' 0 `b' 1
130 pop_input ends $*(c)$@(x) ref: `' 0 `b' 1
131 expand_macro for b, level 0: `' 1 `b' 1
132 pop_input ends $*(c)$@(y) ref: `' 1 `' 0
133 after collect_arguments for b: `a' 1 `' 0
134 push `a(`' to input stack: `a' 1 `' 0
135 push_token saves $1(b) ref: `a' 2 `' 0
136 push `')' to input stack: `a' 2 `' 0
137 exit expand_macro for b: `a' 1 `' 0
138 expand_macro for a, level 0 : `a' 2 `' 0
139 expand_argument gets $1(b) ref: `a'`$1(b)' 3 `' 0
140 pop_input ends $1(b) ref: `a'`$1(b)' 2 `' 0
141 after collect_arguments for a: `a'`$1(b)' 2 `' 0
142 push `A' to input stack: `a'`$1(b)' 2 `' 0
143 expand_macro frees $1(b) ref: `a'`$1(b)' 1 `' 0
144 exit expand_macro for a: `' 0 `' 0
145 output `A': `' 0 `' 0
147 An obstack is only completely cleared when its refcount reaches
148 zero. However, as an optimization, expand_macro also frees
149 anything that it added to the obstack if no additional references
150 were added at the current expansion level, to reduce the amount of
151 memory left on the obstack while waiting for refcounts to drop.
153 struct macro_arg_stacks
155 size_t refcount
; /* Number of active $@ references at this level. */
156 size_t argcount
; /* Number of argv at this level. */
157 struct obstack
*args
; /* Content of arguments. */
158 struct obstack
*argv
; /* Argv pointers into args. */
159 void *args_base
; /* Location for clearing the args obstack. */
160 void *argv_base
; /* Location for clearing the argv obstack. */
163 typedef struct macro_arg_stacks macro_arg_stacks
;
165 static void expand_macro (symbol
*);
166 static bool expand_token (struct obstack
*, token_type
, token_data
*, int,
169 /* Array of stacks, one element per macro recursion level. */
170 static macro_arg_stacks
*stacks
;
172 /* Current size of stacks array. */
173 static size_t stacks_count
;
175 /* Current recursion level in expand_macro (). */
176 int expansion_level
= 0;
178 /* The number of the current call of expand_macro (). */
179 static int macro_call_id
= 0;
181 /* The empty string token. */
182 static token_data empty_token
;
185 /* True if significant changes to stacks should be printed to the
186 trace stream. Primarily useful for debugging $@ ref memory leaks,
187 and controlled by M4_DEBUG_MACRO environment variable. */
188 static int debug_macro_level
;
190 # define debug_macro_level 0
191 #endif /* !DEBUG_MACRO */
192 #define PRINT_ARGCOUNT_CHANGES 1
193 #define PRINT_REFCOUNT_INCREASE 2
194 #define PRINT_REFCOUNT_DECREASE 4
197 /*----------------------------------------------------------------.
198 | This function reads all input, and expands each token, one at a |
200 `----------------------------------------------------------------*/
211 const char *s
= getenv ("M4_DEBUG_MACRO");
213 debug_macro_level
= strtol (s
, NULL
, 0);
214 #endif /* DEBUG_MACRO */
216 TOKEN_DATA_TYPE (&empty_token
) = TOKEN_TEXT
;
217 TOKEN_DATA_TEXT (&empty_token
) = "";
218 TOKEN_DATA_LEN (&empty_token
) = 0;
219 #ifdef ENABLE_CHANGEWORD
220 TOKEN_DATA_ORIG_TEXT (&empty_token
) = "";
223 while ((t
= next_token (&td
, &line
, NULL
, false, NULL
)) != TOKEN_EOF
)
224 expand_token (NULL
, t
, &td
, line
, true);
226 for (i
= 0; i
< stacks_count
; i
++)
228 assert (stacks
[i
].refcount
== 0 && stacks
[i
].argcount
== 0);
231 obstack_free (stacks
[i
].args
, NULL
);
232 free (stacks
[i
].args
);
233 obstack_free (stacks
[i
].argv
, NULL
);
234 free (stacks
[i
].argv
);
243 /*-------------------------------------------------------------------.
244 | Expand one token TD onto the stack OBS, according to its type T, |
245 | which began parsing on the specified LINE. If OBS is NULL, output |
246 | the data. If FIRST, there is no previous text in the current |
247 | argument. Potential macro names (TOKEN_WORD) are looked up in the |
248 | symbol table, to see if they have a macro definition. If they |
249 | have, they are expanded as macros, otherwise the text is just |
250 | copied to the output. Return true if the result is guaranteed to |
251 | give the same parse on rescan in a quoted context, provided |
252 | quoting doesn't change. Returning false is always safe, although |
253 | it may lead to slower performance. |
254 `-------------------------------------------------------------------*/
257 expand_token (struct obstack
*obs
, token_type t
, token_data
*td
, int line
,
268 /* Always safe, since there is no text to rescan. */
272 /* Tokens and comments are safe in isolation (since quote_age()
273 detects any change in delimiters). But if other text is
274 already present, multi-character delimiters could be an
275 issue, so use a conservative heuristic. If obstack is
276 provided, the string was already expanded into it during
278 result
= first
|| safe_quotes ();
286 /* Conservative heuristic; thanks to multi-character delimiter
288 result
= safe_quotes ();
292 /* Conservative heuristic; if these characters are whitespace or
293 numeric, then behavior of safe_quotes is applicable.
294 Otherwise, assume these characters have a high likelihood of
295 use in quote delimiters. */
296 ch
= to_uchar (*TOKEN_DATA_TEXT (td
));
297 result
= (isspace (ch
) || isdigit (ch
)) && safe_quotes ();
301 sym
= lookup_symbol (TOKEN_DATA_TEXT (td
), SYMBOL_LOOKUP
);
302 if (sym
== NULL
|| SYMBOL_TYPE (sym
) == TOKEN_VOID
303 || (SYMBOL_TYPE (sym
) == TOKEN_FUNC
304 && SYMBOL_BLIND_NO_ARGS (sym
)
305 && peek_token () != TOKEN_OPEN
))
307 #ifdef ENABLE_CHANGEWORD
308 shipout_text (obs
, TOKEN_DATA_ORIG_TEXT (td
),
309 TOKEN_DATA_LEN (td
), line
);
311 shipout_text (obs
, TOKEN_DATA_TEXT (td
), TOKEN_DATA_LEN (td
), line
);
312 #endif /* !ENABLE_CHANGEWORD */
313 /* The word just appended is unquoted, but the heuristics of
314 safe_quote are applicable. */
315 return safe_quotes();
318 /* Expanding a macro creates new tokens to scan, and those new
319 tokens may append unsafe text later; but we did not append
324 assert (!"expand_token");
327 shipout_text (obs
, TOKEN_DATA_TEXT (td
), TOKEN_DATA_LEN (td
), line
);
332 /*---------------------------------------------------------------.
333 | Helper function to print warning about concatenating FUNC with |
335 `---------------------------------------------------------------*/
337 warn_builtin_concat (const char *caller
, builtin_func
*func
)
339 const builtin
*bp
= find_builtin_by_addr (func
);
341 m4_warn (0, caller
, _("cannot concatenate builtin `%s'"), bp
->name
);
344 /*-------------------------------------------------------------------.
345 | This function parses one argument to a macro call. It expects the |
346 | first left parenthesis or the separating comma to have been read |
347 | by the caller. It skips leading whitespace, then reads and |
348 | expands tokens, until it finds a comma or right parenthesis at the |
349 | same level of parentheses. It returns a flag indicating whether |
350 | the argument read is the last for the active macro call. The |
351 | argument is built on the obstack OBS, indirectly through |
352 | expand_token (). Report errors on behalf of CALLER. |
353 `-------------------------------------------------------------------*/
356 expand_argument (struct obstack
*obs
, token_data
*argp
, const char *caller
)
361 const char *file
= current_file
;
362 int line
= current_line
;
363 unsigned int age
= quote_age ();
366 TOKEN_DATA_TYPE (argp
) = TOKEN_VOID
;
368 /* Skip leading white space. */
371 t
= next_token (&td
, NULL
, obs
, true, caller
);
373 while (t
== TOKEN_SIMPLE
&& isspace (to_uchar (*TOKEN_DATA_TEXT (&td
))));
384 if (paren_level
== 0)
386 size_t len
= obstack_object_size (obs
);
387 if (TOKEN_DATA_TYPE (argp
) == TOKEN_FUNC
)
390 return t
== TOKEN_COMMA
;
391 warn_builtin_concat (caller
, TOKEN_DATA_FUNC (argp
));
393 if (TOKEN_DATA_TYPE (argp
) != TOKEN_COMP
)
395 TOKEN_DATA_TYPE (argp
) = TOKEN_TEXT
;
398 obstack_1grow (obs
, '\0');
399 TOKEN_DATA_TEXT (argp
) = (char *) obstack_finish (obs
);
402 TOKEN_DATA_TEXT (argp
) = NULL
;
403 TOKEN_DATA_LEN (argp
) = len
;
404 TOKEN_DATA_QUOTE_AGE (argp
) = age
;
407 make_text_link (obs
, NULL
, &argp
->u
.u_c
.end
);
408 return t
== TOKEN_COMMA
;
415 else if (t
== TOKEN_CLOSE
)
417 if (!expand_token (obs
, t
, &td
, line
, first
))
422 /* Current_file changed to "" if we see TOKEN_EOF, use the
423 previous value we stored earlier. */
424 m4_error_at_line (EXIT_FAILURE
, 0, file
, line
, caller
,
425 _("end of file in argument list"));
430 if (!expand_token (obs
, t
, &td
, line
, first
))
432 if (TOKEN_DATA_TYPE (&td
) == TOKEN_COMP
)
434 if (TOKEN_DATA_TYPE (argp
) != TOKEN_COMP
)
436 if (TOKEN_DATA_TYPE (argp
) == TOKEN_FUNC
)
437 warn_builtin_concat (caller
, TOKEN_DATA_FUNC (argp
));
438 TOKEN_DATA_TYPE (argp
) = TOKEN_COMP
;
439 argp
->u
.u_c
.chain
= td
.u
.u_c
.chain
;
440 argp
->u
.u_c
.wrapper
= argp
->u
.u_c
.has_func
= false;
444 assert (argp
->u
.u_c
.end
);
445 argp
->u
.u_c
.end
->next
= td
.u
.u_c
.chain
;
447 argp
->u
.u_c
.end
= td
.u
.u_c
.end
;
448 if (td
.u
.u_c
.has_func
)
449 argp
->u
.u_c
.has_func
= true;
454 if (TOKEN_DATA_TYPE (argp
) == TOKEN_VOID
455 && obstack_object_size (obs
) == 0)
457 TOKEN_DATA_TYPE (argp
) = TOKEN_FUNC
;
458 TOKEN_DATA_FUNC (argp
) = TOKEN_DATA_FUNC (&td
);
462 if (TOKEN_DATA_TYPE (argp
) == TOKEN_FUNC
)
463 warn_builtin_concat (caller
, TOKEN_DATA_FUNC (argp
));
464 warn_builtin_concat (caller
, TOKEN_DATA_FUNC (&td
));
465 TOKEN_DATA_TYPE (argp
) = TOKEN_TEXT
;
470 assert (paren_level
== 0 && TOKEN_DATA_TYPE (argp
) == TOKEN_VOID
471 && obstack_object_size (obs
) == 0
472 && td
.u
.u_c
.chain
== td
.u
.u_c
.end
473 && td
.u
.u_c
.chain
->type
== CHAIN_ARGV
);
474 TOKEN_DATA_TYPE (argp
) = TOKEN_COMP
;
475 argp
->u
.u_c
.chain
= argp
->u
.u_c
.end
= td
.u
.u_c
.chain
;
476 argp
->u
.u_c
.wrapper
= true;
477 argp
->u
.u_c
.has_func
= td
.u
.u_c
.has_func
;
478 t
= next_token (&td
, NULL
, NULL
, false, caller
);
479 if (argp
->u
.u_c
.chain
->u
.u_a
.skip_last
)
480 assert (t
== TOKEN_COMMA
);
482 assert (t
== TOKEN_COMMA
|| t
== TOKEN_CLOSE
);
483 return t
== TOKEN_COMMA
;
486 assert (!"expand_argument");
490 if (TOKEN_DATA_TYPE (argp
) != TOKEN_VOID
|| obstack_object_size (obs
))
492 t
= next_token (&td
, NULL
, obs
, first
, caller
);
496 /*-------------------------------------------------------------------------.
497 | Collect all the arguments to a call of the macro SYM. The arguments are |
498 | stored on the obstack ARGUMENTS and a table of pointers to the arguments |
499 | on the obstack argv_stack. |
500 `-------------------------------------------------------------------------*/
502 static macro_arguments
*
503 collect_arguments (symbol
*sym
, struct obstack
*arguments
,
504 struct obstack
*argv_stack
)
509 bool groks_macro_args
= SYMBOL_MACRO_ARGS (sym
);
510 macro_arguments args
;
511 macro_arguments
*argv
;
515 args
.wrapper
= false;
516 args
.has_ref
= false;
517 args
.flatten
= !groks_macro_args
;
518 args
.has_func
= false;
519 args
.argv0
= SYMBOL_NAME (sym
);
520 args
.argv0_len
= strlen (args
.argv0
);
521 args
.quote_age
= quote_age ();
522 args
.level
= expansion_level
- 1;
524 obstack_grow (argv_stack
, &args
, offsetof (macro_arguments
, array
));
526 if (peek_token () == TOKEN_OPEN
)
528 /* gobble parenthesis */
529 next_token (&td
, NULL
, NULL
, false, SYMBOL_NAME (sym
));
532 tdp
= (token_data
*) obstack_alloc (arguments
, sizeof *tdp
);
533 more_args
= expand_argument (arguments
, tdp
, SYMBOL_NAME (sym
));
535 if ((TOKEN_DATA_TYPE (tdp
) == TOKEN_TEXT
&& !TOKEN_DATA_LEN (tdp
))
536 || (!groks_macro_args
&& TOKEN_DATA_TYPE (tdp
) == TOKEN_FUNC
))
538 obstack_free (arguments
, tdp
);
541 obstack_ptr_grow (argv_stack
, tdp
);
544 switch (TOKEN_DATA_TYPE (tdp
))
547 /* Be conservative - any change in quoting while
548 collecting arguments, or any argument that consists
549 of unsafe text, will require a rescan if $@ is
551 if (TOKEN_DATA_LEN (tdp
) > 0
552 && TOKEN_DATA_QUOTE_AGE (tdp
) != args
.quote_age
)
556 args
.has_func
= true;
560 if (tdp
->u
.u_c
.wrapper
)
562 assert (tdp
->u
.u_c
.chain
->type
== CHAIN_ARGV
563 && !tdp
->u
.u_c
.chain
->next
);
564 args
.argc
+= (tdp
->u
.u_c
.chain
->u
.u_a
.argv
->argc
565 - tdp
->u
.u_c
.chain
->u
.u_a
.index
566 - tdp
->u
.u_c
.chain
->u
.u_a
.skip_last
- 1);
569 if (tdp
->u
.u_c
.has_func
)
570 args
.has_func
= true;
573 assert (!"expand_argument");
579 argv
= (macro_arguments
*) obstack_finish (argv_stack
);
580 argv
->argc
= args
.argc
;
581 argv
->wrapper
= args
.wrapper
;
582 argv
->has_ref
= args
.has_ref
;
583 argv
->has_func
= args
.has_func
;
584 if (args
.quote_age
!= quote_age ())
586 argv
->arraylen
= args
.arraylen
;
591 /*-----------------------------------------------------------------.
592 | Call the macro SYM, which is either a builtin function or a user |
593 | macro (via the expansion function expand_user_macro () in |
594 | builtin.c). There are ARGC arguments to the call, stored in the |
595 | ARGV table. The expansion is left on the obstack EXPANSION. |
596 `-----------------------------------------------------------------*/
599 call_macro (symbol
*sym
, int argc
, macro_arguments
*argv
,
600 struct obstack
*expansion
)
602 switch (SYMBOL_TYPE (sym
))
605 SYMBOL_FUNC (sym
) (expansion
, argc
, argv
);
609 expand_user_macro (expansion
, sym
, argc
, argv
);
613 assert (!"call_macro");
618 /*-------------------------------------------------------------------------.
619 | The macro expansion is handled by expand_macro (). It parses the |
620 | arguments, using collect_arguments (), and builds a table of pointers to |
621 | the arguments. The arguments themselves are stored on a local obstack. |
622 | Expand_macro () uses call_macro () to do the call of the macro. |
624 | Expand_macro () is potentially recursive, since it calls expand_argument |
625 | (), which might call expand_token (), which might call expand_macro (). |
626 `-------------------------------------------------------------------------*/
629 expand_macro (symbol
*sym
)
631 void *args_base
; /* Base of stacks[i].args on entry. */
632 void *args_scratch
; /* Base of scratch space for call_macro. */
633 void *argv_base
; /* Base of stacks[i].argv on entry. */
634 macro_arguments
*argv
; /* Arguments to the called macro. */
635 struct obstack
*expansion
; /* Collects the macro's expansion. */
636 const input_block
*expanded
; /* The resulting expansion, for tracing. */
637 bool traced
; /* True if this macro is traced. */
638 int my_call_id
; /* Sequence id for this macro. */
639 int level
= expansion_level
; /* Expansion level of this macro. */
641 /* Report errors at the location where the open parenthesis (if any)
642 was found, but after expansion, restore global state back to the
643 location of the close parenthesis. This is safe since we
644 guarantee that macro expansion does not alter the state of
645 current_file/current_line (dnl, include, and sinclude are special
646 cased in the input engine to ensure this fact). */
647 const char *loc_open_file
= current_file
;
648 int loc_open_line
= current_line
;
649 const char *loc_close_file
;
652 /* Obstack preparation. */
653 if (level
>= stacks_count
)
655 size_t old_count
= stacks_count
;
656 stacks
= (macro_arg_stacks
*) x2nrealloc (stacks
, &stacks_count
,
658 memset (&stacks
[old_count
], 0,
659 sizeof *stacks
* (stacks_count
- old_count
));
661 if (!stacks
[level
].args
)
663 assert (!stacks
[level
].refcount
);
664 stacks
[level
].args
= xmalloc (sizeof (struct obstack
));
665 stacks
[level
].argv
= xmalloc (sizeof (struct obstack
));
666 obstack_init (stacks
[level
].args
);
667 obstack_init (stacks
[level
].argv
);
668 stacks
[level
].args_base
= obstack_finish (stacks
[level
].args
);
669 stacks
[level
].argv_base
= obstack_finish (stacks
[level
].argv
);
671 assert (obstack_object_size (stacks
[level
].args
) == 0
672 && obstack_object_size (stacks
[level
].argv
) == 0);
673 args_base
= obstack_finish (stacks
[level
].args
);
674 argv_base
= obstack_finish (stacks
[level
].argv
);
675 adjust_refcount (level
, true);
676 stacks
[level
].argcount
++;
678 /* Prepare for argument collection. */
679 SYMBOL_PENDING_EXPANSIONS (sym
)++;
681 if (nesting_limit
> 0 && expansion_level
> nesting_limit
)
682 m4_error (EXIT_FAILURE
, 0, NULL
,
683 _("recursion limit of %d exceeded, use -L<N> to change it"),
687 my_call_id
= macro_call_id
;
689 traced
= (debug_level
& DEBUG_TRACE_ALL
) || SYMBOL_TRACED (sym
);
690 if (traced
&& (debug_level
& DEBUG_TRACE_CALL
))
691 trace_prepre (SYMBOL_NAME (sym
), my_call_id
);
693 argv
= collect_arguments (sym
, stacks
[level
].args
, stacks
[level
].argv
);
694 args_scratch
= obstack_finish (stacks
[level
].args
);
696 /* The actual macro call. */
697 loc_close_file
= current_file
;
698 loc_close_line
= current_line
;
699 current_file
= loc_open_file
;
700 current_line
= loc_open_line
;
703 trace_pre (SYMBOL_NAME (sym
), my_call_id
, argv
);
705 expansion
= push_string_init ();
706 call_macro (sym
, argv
->argc
, argv
, expansion
);
707 expanded
= push_string_finish ();
710 trace_post (SYMBOL_NAME (sym
), my_call_id
, argv
, expanded
);
713 current_file
= loc_close_file
;
714 current_line
= loc_close_line
;
717 --SYMBOL_PENDING_EXPANSIONS (sym
);
719 if (SYMBOL_DELETED (sym
))
722 /* We no longer need argv, so reduce the refcount. Additionally, if
723 no other references to argv were created, we can free our portion
724 of the obstack, although we must leave earlier content alone. A
725 refcount of 0 implies that adjust_refcount already freed the
727 arg_adjust_refcount (argv
, false);
728 if (stacks
[level
].refcount
)
732 obstack_free (stacks
[level
].args
, args_scratch
);
733 if (debug_macro_level
& PRINT_ARGCOUNT_CHANGES
)
734 xfprintf (debug
, "m4debug: -%d- `%s' in use, level=%d, "
735 "refcount=%zu, argcount=%zu\n", my_call_id
, argv
->argv0
,
736 level
, stacks
[level
].refcount
, stacks
[level
].argcount
);
740 obstack_free (stacks
[level
].args
, args_base
);
741 obstack_free (stacks
[level
].argv
, argv_base
);
742 stacks
[level
].argcount
--;
747 /* Adjust the refcount of argument stack LEVEL. If INCREASE, then
748 increase the count, otherwise decrease the count and clear the
749 entire stack if the new count is zero. Return the new
752 adjust_refcount (int level
, bool increase
)
754 assert (level
>= 0 && level
< stacks_count
&& stacks
[level
].args
);
755 assert (increase
|| stacks
[level
].refcount
);
757 stacks
[level
].refcount
++;
758 else if (--stacks
[level
].refcount
== 0)
760 obstack_free (stacks
[level
].args
, stacks
[level
].args_base
);
761 obstack_free (stacks
[level
].argv
, stacks
[level
].argv_base
);
762 if ((debug_macro_level
& PRINT_ARGCOUNT_CHANGES
)
763 && stacks
[level
].argcount
> 1)
764 xfprintf (debug
, "m4debug: -%d- freeing %zu args, level=%d\n",
765 macro_call_id
, stacks
[level
].argcount
, level
);
766 stacks
[level
].argcount
= 0;
768 if (debug_macro_level
769 & (increase
? PRINT_REFCOUNT_INCREASE
: PRINT_REFCOUNT_DECREASE
))
770 xfprintf (debug
, "m4debug: level %d refcount=%d\n", level
,
771 stacks
[level
].refcount
);
772 return stacks
[level
].refcount
;
775 /* Given ARGV, adjust the refcount of every reference it contains in
776 the direction decided by INCREASE. Return true if increasing
777 references to ARGV implies the first use of ARGV. */
779 arg_adjust_refcount (macro_arguments
*argv
, bool increase
)
783 bool result
= !argv
->inuse
;
786 for (i
= 0; i
< argv
->arraylen
; i
++)
787 if (TOKEN_DATA_TYPE (argv
->array
[i
]) == TOKEN_COMP
)
789 chain
= argv
->array
[i
]->u
.u_c
.chain
;
795 if (chain
->u
.u_s
.level
>= 0)
796 adjust_refcount (chain
->u
.u_s
.level
, increase
);
799 assert (chain
->u
.u_a
.argv
->inuse
);
800 arg_adjust_refcount (chain
->u
.u_a
.argv
, increase
);
803 assert (!"arg_adjust_refcount");
809 adjust_refcount (argv
->level
, increase
);
814 /* Given ARGV, return the token_data that contains argument INDEX;
815 INDEX must be > 0, < argv->argc. If LEVEL is non-NULL, *LEVEL is
816 set to the obstack level that contains the token (which is not
817 necessarily the level of ARGV). */
819 arg_token (macro_arguments
*argv
, unsigned int index
, int *level
)
824 assert (index
&& index
< argv
->argc
);
826 *level
= argv
->level
;
828 return argv
->array
[index
- 1];
830 /* Must cycle through all tokens, until we find index, since a ref
831 may occupy multiple indices. */
832 for (i
= 0; i
< argv
->arraylen
; i
++)
834 token
= argv
->array
[i
];
835 if (TOKEN_DATA_TYPE (token
) == TOKEN_COMP
&& token
->u
.u_c
.wrapper
)
837 token_chain
*chain
= token
->u
.u_c
.chain
;
838 assert (!chain
->next
&& chain
->type
== CHAIN_ARGV
);
839 if (index
<= (chain
->u
.u_a
.argv
->argc
- chain
->u
.u_a
.index
840 - chain
->u
.u_a
.skip_last
))
842 token
= arg_token (chain
->u
.u_a
.argv
,
843 chain
->u
.u_a
.index
- 1 + index
, level
);
844 if (chain
->u
.u_a
.flatten
845 && TOKEN_DATA_TYPE (token
) == TOKEN_FUNC
)
846 token
= &empty_token
;
849 index
-= (chain
->u
.u_a
.argv
->argc
- chain
->u
.u_a
.index
850 - chain
->u
.u_a
.skip_last
);
852 else if (--index
== 0)
858 /* Mark ARGV as being in use, along with any $@ references that it
861 arg_mark (macro_arguments
*argv
)
870 for (i
= 0; i
< argv
->arraylen
; i
++)
871 if (TOKEN_DATA_TYPE (argv
->array
[i
]) == TOKEN_COMP
872 && argv
->array
[i
]->u
.u_c
.wrapper
)
874 chain
= argv
->array
[i
]->u
.u_c
.chain
;
875 assert (!chain
->next
&& chain
->type
== CHAIN_ARGV
);
876 if (!chain
->u
.u_a
.argv
->inuse
)
877 arg_mark (chain
->u
.u_a
.argv
);
881 /* Given ARGV, return how many arguments it refers to. */
883 arg_argc (macro_arguments
*argv
)
888 /* Given ARGV, return the type of argument INDEX. Index 0 is always
889 text, and indices beyond argc are likewise treated as text. */
891 arg_type (macro_arguments
*argv
, unsigned int index
)
893 token_data_type type
;
896 if (argv
->flatten
|| !argv
->has_func
|| index
== 0 || index
>= argv
->argc
)
898 token
= arg_token (argv
, index
, NULL
);
899 type
= TOKEN_DATA_TYPE (token
);
900 if (type
== TOKEN_COMP
&& !token
->u
.u_c
.has_func
)
902 if (type
!= TOKEN_TEXT
)
903 assert (argv
->has_func
);
904 /* TODO support TOKEN_COMP meaning concatenation of builtins. */
905 assert (type
!= TOKEN_COMP
);
909 /* Given ARGV, return the text at argument INDEX. Abort if the
910 argument is not text. Index 0 is always text, and indices beyond
911 argc return the empty string. The result is always NUL-terminated,
912 even if it includes embedded NUL characters. */
914 arg_text (macro_arguments
*argv
, unsigned int index
)
918 struct obstack
*obs
; /* Scratch space; cleaned at end of macro_expand. */
922 if (index
>= argv
->argc
)
924 token
= arg_token (argv
, index
, NULL
);
925 switch (TOKEN_DATA_TYPE (token
))
928 return TOKEN_DATA_TEXT (token
);
930 /* TODO - concatenate functions. */
931 chain
= token
->u
.u_c
.chain
;
932 obs
= arg_scratch ();
938 obstack_grow (obs
, chain
->u
.u_s
.str
, chain
->u
.u_s
.len
);
941 arg_print (obs
, chain
->u
.u_a
.argv
, chain
->u
.u_a
.index
,
942 quote_cache (NULL
, chain
->quote_age
,
943 chain
->u
.u_a
.quotes
),
944 chain
->u
.u_a
.flatten
, NULL
, NULL
, false);
947 assert (!"arg_text");
952 obstack_1grow (obs
, '\0');
953 return (char *) obstack_finish (obs
);
957 assert (!"arg_text");
961 /* Given ARGV, compare text arguments INDEXA and INDEXB for equality.
962 Both indices must be non-zero and less than argc. Return true if
963 the arguments contain the same contents; often more efficient than
964 strcmp (arg_text (argv, indexa), arg_text (argv, indexb)) == 0. */
966 arg_equal (macro_arguments
*argv
, unsigned int indexa
, unsigned int indexb
)
968 token_data
*ta
= arg_token (argv
, indexa
, NULL
);
969 token_data
*tb
= arg_token (argv
, indexb
, NULL
);
972 token_chain
*ca
= &tmpa
;
973 token_chain
*cb
= &tmpb
;
974 struct obstack
*obs
= arg_scratch ();
977 if (ta
== &empty_token
|| tb
== &empty_token
)
979 if (TOKEN_DATA_TYPE (ta
) == TOKEN_TEXT
980 && TOKEN_DATA_TYPE (tb
) == TOKEN_TEXT
)
981 return (TOKEN_DATA_LEN (ta
) == TOKEN_DATA_LEN (tb
)
982 && memcmp (TOKEN_DATA_TEXT (ta
), TOKEN_DATA_TEXT (tb
),
983 TOKEN_DATA_LEN (ta
)) == 0);
985 /* Convert both arguments to chains, if not one already. */
986 /* TODO - allow builtin tokens in the comparison? */
987 if (TOKEN_DATA_TYPE (ta
) == TOKEN_TEXT
)
990 tmpa
.type
= CHAIN_STR
;
991 tmpa
.u
.u_s
.str
= TOKEN_DATA_TEXT (ta
);
992 tmpa
.u
.u_s
.len
= TOKEN_DATA_LEN (ta
);
996 assert (TOKEN_DATA_TYPE (ta
) == TOKEN_COMP
);
997 ca
= ta
->u
.u_c
.chain
;
999 if (TOKEN_DATA_TYPE (tb
) == TOKEN_TEXT
)
1002 tmpb
.type
= CHAIN_STR
;
1003 tmpb
.u
.u_s
.str
= TOKEN_DATA_TEXT (tb
);
1004 tmpb
.u
.u_s
.len
= TOKEN_DATA_LEN (tb
);
1008 assert (TOKEN_DATA_TYPE (tb
) == TOKEN_COMP
);
1009 cb
= tb
->u
.u_c
.chain
;
1012 /* Compare each link of the chain. */
1015 if (ca
->type
== CHAIN_ARGV
)
1017 tmpa
.next
= ca
->next
;
1018 tmpa
.type
= CHAIN_STR
;
1019 /* TODO support $@ with funcs. */
1020 assert (!ca
->u
.u_a
.has_func
|| argv
->flatten
|| ca
->u
.u_a
.flatten
);
1021 arg_print (obs
, ca
->u
.u_a
.argv
, ca
->u
.u_a
.index
,
1022 quote_cache (NULL
, ca
->quote_age
, ca
->u
.u_a
.quotes
),
1023 argv
->flatten
|| ca
->u
.u_a
.flatten
, NULL
, NULL
, false);
1024 tmpa
.u
.u_s
.len
= obstack_object_size (obs
);
1025 tmpa
.u
.u_s
.str
= (char *) obstack_finish (obs
);
1029 if (cb
->type
== CHAIN_ARGV
)
1031 tmpb
.next
= cb
->next
;
1032 tmpb
.type
= CHAIN_STR
;
1033 /* TODO support $@ with funcs. */
1034 assert (!cb
->u
.u_a
.has_func
|| argv
->flatten
|| cb
->u
.u_a
.flatten
);
1035 arg_print (obs
, cb
->u
.u_a
.argv
, cb
->u
.u_a
.index
,
1036 quote_cache (NULL
, cb
->quote_age
, cb
->u
.u_a
.quotes
),
1037 argv
->flatten
|| cb
->u
.u_a
.flatten
, NULL
, NULL
, false);
1038 tmpb
.u
.u_s
.len
= obstack_object_size (obs
);
1039 tmpb
.u
.u_s
.str
= (char *) obstack_finish (obs
);
1043 assert (ca
->type
== CHAIN_STR
&& cb
->type
== CHAIN_STR
);
1044 if (ca
->u
.u_s
.len
== cb
->u
.u_s
.len
)
1046 if (memcmp (ca
->u
.u_s
.str
, cb
->u
.u_s
.str
, ca
->u
.u_s
.len
) != 0)
1051 else if (ca
->u
.u_s
.len
< cb
->u
.u_s
.len
)
1053 if (memcmp (ca
->u
.u_s
.str
, cb
->u
.u_s
.str
, ca
->u
.u_s
.len
) != 0)
1055 tmpb
.next
= cb
->next
;
1056 tmpb
.type
= CHAIN_STR
;
1057 tmpb
.u
.u_s
.str
= cb
->u
.u_s
.str
+ ca
->u
.u_s
.len
;
1058 tmpb
.u
.u_s
.len
= cb
->u
.u_s
.len
- ca
->u
.u_s
.len
;
1064 assert (ca
->u
.u_s
.len
> cb
->u
.u_s
.len
);
1065 if (memcmp (ca
->u
.u_s
.str
, cb
->u
.u_s
.str
, cb
->u
.u_s
.len
) != 0)
1067 tmpa
.next
= ca
->next
;
1068 tmpa
.type
= CHAIN_STR
;
1069 tmpa
.u
.u_s
.str
= ca
->u
.u_s
.str
+ cb
->u
.u_s
.len
;
1070 tmpa
.u
.u_s
.len
= ca
->u
.u_s
.len
- cb
->u
.u_s
.len
;
1076 /* If we get this far, the two tokens are equal only if both chains
1078 assert (ca
!= cb
|| ca
== NULL
);
1082 /* Given ARGV, return true if argument INDEX is the empty string.
1083 This gives the same result as comparing arg_len against 0, but is
1086 arg_empty (macro_arguments
*argv
, unsigned int index
)
1089 return argv
->argv0_len
== 0;
1090 if (index
>= argv
->argc
)
1092 return arg_token (argv
, index
, NULL
) == &empty_token
;
1095 /* Given ARGV, return the length of argument INDEX. Abort if the
1096 argument is not text. Indices beyond argc return 0. */
1098 arg_len (macro_arguments
*argv
, unsigned int index
)
1105 return argv
->argv0_len
;
1106 if (index
>= argv
->argc
)
1108 token
= arg_token (argv
, index
, NULL
);
1109 switch (TOKEN_DATA_TYPE (token
))
1112 assert ((token
== &empty_token
) == (TOKEN_DATA_LEN (token
) == 0));
1113 return TOKEN_DATA_LEN (token
);
1115 chain
= token
->u
.u_c
.chain
;
1121 const string_pair
*quotes
;
1122 switch (chain
->type
)
1125 len
+= chain
->u
.u_s
.len
;
1128 i
= chain
->u
.u_a
.index
;
1129 limit
= chain
->u
.u_a
.argv
->argc
- i
- chain
->u
.u_a
.skip_last
;
1130 quotes
= quote_cache (NULL
, chain
->quote_age
,
1131 chain
->u
.u_a
.quotes
);
1134 len
+= (quotes
->len1
+ quotes
->len2
) * limit
;
1138 /* TODO handle builtin concatenation. */
1139 if (TOKEN_DATA_TYPE (arg_token (chain
->u
.u_a
.argv
, i
,
1140 NULL
)) == TOKEN_FUNC
)
1141 assert (argv
->flatten
);
1143 len
+= arg_len (chain
->u
.u_a
.argv
, i
);
1148 assert (!"arg_len");
1151 chain
= chain
->next
;
1158 assert (!"arg_len");
1162 /* Given ARGV, return the builtin function referenced by argument
1163 INDEX. Abort if it is not a builtin in isolation. */
1165 arg_func (macro_arguments
*argv
, unsigned int index
)
1169 token
= arg_token (argv
, index
, NULL
);
1170 assert (TOKEN_DATA_TYPE (token
) == TOKEN_FUNC
);
1171 return TOKEN_DATA_FUNC (token
);
1174 /* Return an obstack useful for scratch calculations that will not
1175 interfere with macro expansion. The obstack will be reset when
1176 expand_macro completes. */
1180 assert (obstack_object_size (stacks
[expansion_level
- 1].args
) == 0);
1181 return stacks
[expansion_level
- 1].args
;
1184 /* Dump a representation of ARGV to the obstack OBS, starting with
1185 argument INDEX. If QUOTES is non-NULL, each argument is displayed
1186 with those quotes. If FLATTEN, builtins are ignored. Separate
1187 arguments with SEP, which defaults to a comma. If MAX_LEN is
1188 non-NULL, truncate the output after *MAX_LEN bytes are output and
1189 return true; otherwise, return false, and reduce *MAX_LEN by the
1190 number of bytes output. If QUOTE_EACH, the truncation length is
1191 reset for each argument, quotes do not count against length, and
1192 all arguments are printed; otherwise, quotes count against the
1193 length and trailing arguments may be discarded. */
1195 arg_print (struct obstack
*obs
, macro_arguments
*argv
, unsigned int index
,
1196 const string_pair
*quotes
, bool flatten
, const char *sep
,
1197 int *max_len
, bool quote_each
)
1199 int len
= max_len
? *max_len
: INT_MAX
;
1203 bool use_sep
= false;
1206 size_t *plen
= quote_each
? NULL
: &len
;
1210 sep_len
= strlen (sep
);
1211 for (i
= index
; i
< argv
->argc
; i
++)
1213 if (quote_each
&& max_len
)
1215 if (use_sep
&& obstack_print (obs
, sep
, sep_len
, plen
))
1218 token
= arg_token (argv
, i
, NULL
);
1219 switch (TOKEN_DATA_TYPE (token
))
1222 if (quotes
&& obstack_print (obs
, quotes
->str1
, quotes
->len1
, plen
))
1224 if (obstack_print (obs
, TOKEN_DATA_TEXT (token
),
1225 TOKEN_DATA_LEN (token
), &len
) && !quote_each
)
1227 if (quotes
&& obstack_print (obs
, quotes
->str2
, quotes
->len2
, plen
))
1231 if (quotes
&& obstack_print (obs
, quotes
->str1
, quotes
->len1
, plen
))
1233 chain
= token
->u
.u_c
.chain
;
1235 while (chain
&& !done
)
1237 switch (chain
->type
)
1240 if (obstack_print (obs
, chain
->u
.u_s
.str
, chain
->u
.u_s
.len
,
1245 if (arg_print (obs
, chain
->u
.u_a
.argv
, chain
->u
.u_a
.index
,
1246 quote_cache (NULL
, chain
->quote_age
,
1247 chain
->u
.u_a
.quotes
),
1248 flatten
, NULL
, &len
, false))
1252 assert (!"arg_print");
1255 chain
= chain
->next
;
1257 if (done
&& !quote_each
)
1259 if (quotes
&& obstack_print (obs
, quotes
->str2
, quotes
->len2
, plen
))
1263 func_print (obs
, find_builtin_by_addr (TOKEN_DATA_FUNC (token
)),
1267 assert (!"arg_print");
1276 /* Populate the new TOKEN as a wrapper to ARGV, starting with argument
1277 INDEX. Allocate any data on OBS, owned by a given expansion LEVEL.
1278 FLATTEN determines whether to allow builtins, and QUOTES determines
1279 whether all arguments are quoted. Return TOKEN when successful,
1280 NULL when wrapping ARGV is trivially empty. */
1282 make_argv_ref_token (token_data
*token
, struct obstack
*obs
, int level
,
1283 macro_arguments
*argv
, unsigned int index
, bool flatten
,
1284 const string_pair
*quotes
)
1288 if (index
>= argv
->argc
)
1290 TOKEN_DATA_TYPE (token
) = TOKEN_COMP
;
1291 token
->u
.u_c
.chain
= token
->u
.u_c
.end
= NULL
;
1293 /* Cater to the common idiom of $0(`$1',shift(shift($@))), by
1294 inlining the first few arguments and reusing the original $@ ref,
1295 rather than creating another layer of wrappers. */
1296 while (argv
->wrapper
)
1299 for (i
= 0; i
< argv
->arraylen
; i
++)
1301 if (TOKEN_DATA_TYPE (argv
->array
[i
]) == TOKEN_COMP
1302 && argv
->array
[i
]->u
.u_c
.wrapper
)
1306 push_arg_quote (obs
, argv
, i
+ 1, quotes
);
1307 obstack_1grow (obs
, ',');
1312 assert (i
< argv
->arraylen
);
1313 if (i
+ 1 == argv
->arraylen
)
1315 assert (TOKEN_DATA_TYPE (argv
->array
[i
]) == TOKEN_COMP
1316 && argv
->array
[i
]->u
.u_c
.wrapper
);
1317 chain
= argv
->array
[i
]->u
.u_c
.chain
;
1318 assert (!chain
->next
&& chain
->type
== CHAIN_ARGV
1319 && !chain
->u
.u_a
.skip_last
);
1320 argv
= chain
->u
.u_a
.argv
;
1321 index
+= chain
->u
.u_a
.index
- 1;
1330 make_text_link (obs
, &token
->u
.u_c
.chain
, &token
->u
.u_c
.end
);
1331 chain
= (token_chain
*) obstack_alloc (obs
, sizeof *chain
);
1332 if (token
->u
.u_c
.end
)
1333 token
->u
.u_c
.end
->next
= chain
;
1335 token
->u
.u_c
.chain
= chain
;
1336 token
->u
.u_c
.end
= chain
;
1337 token
->u
.u_c
.wrapper
= true;
1338 token
->u
.u_c
.has_func
= argv
->has_func
;
1340 chain
->type
= CHAIN_ARGV
;
1341 chain
->quote_age
= argv
->quote_age
;
1342 chain
->u
.u_a
.argv
= argv
;
1343 chain
->u
.u_a
.index
= index
;
1344 chain
->u
.u_a
.flatten
= flatten
;
1345 chain
->u
.u_a
.has_func
= argv
->has_func
;
1346 chain
->u
.u_a
.comma
= false;
1347 chain
->u
.u_a
.skip_last
= false;
1348 chain
->u
.u_a
.quotes
= quote_cache (obs
, chain
->quote_age
, quotes
);
1352 /* Create a new argument object using the same obstack as ARGV; thus,
1353 the new object will automatically be freed when the original is
1354 freed. Explicitly set the macro name (argv[0]) from ARGV0 with
1355 length ARGV0_LEN. If SKIP, set argv[1] of the new object to
1356 argv[2] of the old, otherwise the objects share all arguments. If
1357 FLATTEN, any non-text in ARGV is flattened to an empty string when
1358 referenced through the new object. */
1360 make_argv_ref (macro_arguments
*argv
, const char *argv0
, size_t argv0_len
,
1361 bool skip
, bool flatten
)
1363 macro_arguments
*new_argv
;
1365 token_data
*new_token
;
1366 unsigned int index
= skip
? 2 : 1;
1367 struct obstack
*obs
= arg_scratch ();
1369 new_token
= (token_data
*) obstack_alloc (obs
, sizeof *token
);
1370 token
= make_argv_ref_token (new_token
, obs
, expansion_level
- 1, argv
,
1371 index
, flatten
, NULL
);
1374 obstack_free (obs
, new_token
);
1375 new_argv
= (macro_arguments
*)
1376 obstack_alloc (obs
, offsetof (macro_arguments
, array
));
1377 new_argv
->arraylen
= 0;
1378 new_argv
->wrapper
= false;
1379 new_argv
->has_ref
= false;
1380 new_argv
->flatten
= false;
1381 new_argv
->has_func
= false;
1385 new_argv
= (macro_arguments
*)
1386 obstack_alloc (obs
, offsetof (macro_arguments
, array
) + sizeof token
);
1387 new_argv
->arraylen
= 1;
1388 new_argv
->array
[0] = token
;
1389 new_argv
->wrapper
= true;
1390 new_argv
->has_ref
= argv
->has_ref
;
1391 new_argv
->flatten
= flatten
;
1392 new_argv
->has_func
= argv
->has_func
;
1394 new_argv
->argc
= argv
->argc
- (index
- 1);
1395 new_argv
->inuse
= false;
1396 new_argv
->argv0
= argv0
;
1397 new_argv
->argv0_len
= argv0_len
;
1398 new_argv
->quote_age
= argv
->quote_age
;
1399 new_argv
->level
= argv
->level
;
1403 /* Push argument INDEX from ARGV, which must be a text token, onto the
1404 expansion stack OBS for rescanning. */
1406 push_arg (struct obstack
*obs
, macro_arguments
*argv
, unsigned int index
)
1410 /* Always push copy of arg 0, since its lifetime is not
1411 guaranteed beyond expand_macro. */
1412 obstack_grow (obs
, argv
->argv0
, argv
->argv0_len
);
1415 if (index
>= argv
->argc
)
1417 push_arg_quote (obs
, argv
, index
, NULL
);
1420 /* Push argument INDEX from ARGV, which must be a text token, onto the
1421 expansion stack OBS for rescanning. INDEX must be > 0, < argc.
1422 QUOTES determines any quote delimiters that were in effect when the
1423 reference was created. */
1425 push_arg_quote (struct obstack
*obs
, macro_arguments
*argv
, unsigned int index
,
1426 const string_pair
*quotes
)
1429 token_data
*token
= arg_token (argv
, index
, &level
);
1431 /* TODO handle func tokens. */
1433 obstack_grow (obs
, quotes
->str1
, quotes
->len1
);
1434 if (push_token (token
, level
, argv
->inuse
))
1437 obstack_grow (obs
, quotes
->str2
, quotes
->len2
);
1440 /* Push series of comma-separated arguments from ARGV, which can
1441 include builtins, onto the expansion stack OBS for rescanning. If
1442 SKIP, then don't push the first argument. If QUOTE, the rescan
1443 also includes quoting around each arg. */
1445 push_args (struct obstack
*obs
, macro_arguments
*argv
, bool skip
, bool quote
)
1447 unsigned int i
= skip
? 2 : 1;
1451 if (i
>= argv
->argc
)
1454 if (i
+ 1 == argv
->argc
)
1456 push_arg_quote (obs
, argv
, i
, quote
? &curr_quote
: NULL
);
1460 /* TODO allow shift, $@, to push builtins without flatten. */
1461 token
= make_argv_ref_token (&td
, obs
, -1, argv
, i
, true,
1462 quote
? &curr_quote
: NULL
);
1464 if (push_token (token
, -1, argv
->inuse
))