diff options
Diffstat (limited to 'm4/macro.c')
| -rw-r--r-- | m4/macro.c | 1228 |
1 files changed, 614 insertions, 614 deletions
@@ -64,7 +64,7 @@ thresholds of the input engine, the interesting sequence of events is as follows: - stacks[0] refs stacks[1] refs + stacks[0] refs stacks[1] refs after second dnl ends: `' 0 `' 0 expand_macro for x, level 0: `' 1 `' 0 expand_macro for a, level 1: `' 1 `' 1 @@ -121,14 +121,14 @@ */ static m4_macro_args *collect_arguments (m4 *, m4_call_info *, m4_symbol *, - m4_obstack *, m4_obstack *); + m4_obstack *, m4_obstack *); static void expand_macro (m4 *, const char *, size_t, m4_symbol *); static bool expand_token (m4 *, m4_obstack *, m4__token_type, - m4_symbol_value *, int, bool); + m4_symbol_value *, int, bool); static bool expand_argument (m4 *, m4_obstack *, m4_symbol_value *, - const m4_call_info *); + const m4_call_info *); static void process_macro (m4 *, m4_symbol_value *, m4_obstack *, int, - m4_macro_args *); + m4_macro_args *); static unsigned int trace_pre (m4 *, m4_macro_args *); static void trace_post (m4 *, unsigned int, const m4_call_info *); @@ -175,7 +175,7 @@ m4_macro_expand_input (m4 *context) VALUE_MAX_ARGS (&empty_symbol) = -1; while ((type = m4__next_token (context, &token, &line, NULL, false, NULL)) - != M4_TOKEN_EOF) + != M4_TOKEN_EOF) expand_token (context, NULL, type, &token, line, true); } @@ -193,12 +193,12 @@ m4_macro_expand_input (m4 *context) slower performance. */ static bool expand_token (m4 *context, m4_obstack *obs, m4__token_type type, - m4_symbol_value *token, int line, bool first) + m4_symbol_value *token, int line, bool first) { m4_symbol *symbol; bool result = false; const char *text = (m4_is_symbol_value_text (token) - ? m4_get_symbol_value_text (token) : NULL); + ? m4_get_symbol_value_text (token) : NULL); switch (type) { /* TOKSW */ @@ -209,22 +209,22 @@ expand_token (m4 *context, m4_obstack *obs, m4__token_type type, case M4_TOKEN_STRING: /* Strings are safe in isolation (since quote_age detects any - change in delimiters), or when safe_quotes is true. This is - also returned for sequences of benign characters, such as - digits. When safe_quotes is false, we could technically - return true if we can prove that the concatenation of this - string to prior text does not form a multi-byte quote - delimiter, but that is a lot of overhead, so we give the - conservative answer of false. */ + change in delimiters), or when safe_quotes is true. This is + also returned for sequences of benign characters, such as + digits. When safe_quotes is false, we could technically + return true if we can prove that the concatenation of this + string to prior text does not form a multi-byte quote + delimiter, but that is a lot of overhead, so we give the + conservative answer of false. */ result = first || m4__safe_quotes (M4SYNTAX); /* fallthru */ case M4_TOKEN_COMMENT: /* Comments can contain unbalanced quote delimiters. Rather - than search for one, we return the conservative answer of - false. If obstack is provided, the string or comment was - already expanded into it during next_token. */ + than search for one, we return the conservative answer of + false. If obstack is provided, the string or comment was + already expanded into it during next_token. */ if (obs) - return result; + return result; break; case M4_TOKEN_OPEN: @@ -232,56 +232,56 @@ expand_token (m4 *context, m4_obstack *obs, m4__token_type type, case M4_TOKEN_CLOSE: case M4_TOKEN_SPACE: /* If safe_quotes is true, then these do not form a quote - delimiter. If it is false, we give the conservative answer - of false rather than taking time to prove that no multi-byte - quote delimiter is formed. */ + delimiter. If it is false, we give the conservative answer + of false rather than taking time to prove that no multi-byte + quote delimiter is formed. */ result = m4__safe_quotes (M4SYNTAX); break; case M4_TOKEN_SIMPLE: /* If safe_quotes is true, then all but the single-byte end - quote delimiter is safe in a quoted context; a single-byte - start delimiter will trigger M4_TOKEN_STRING instead. If - safe_quotes is false, we give the conservative answer of - false rather than taking time to prove that no multi-byte - quote delimiter is formed. */ + quote delimiter is safe in a quoted context; a single-byte + start delimiter will trigger M4_TOKEN_STRING instead. If + safe_quotes is false, we give the conservative answer of + false rather than taking time to prove that no multi-byte + quote delimiter is formed. */ result = (!m4_has_syntax (M4SYNTAX, *text, M4_SYNTAX_RQUOTE) - && m4__safe_quotes (M4SYNTAX)); + && m4__safe_quotes (M4SYNTAX)); if (result) - assert (!m4_has_syntax (M4SYNTAX, *text, M4_SYNTAX_LQUOTE)); + assert (!m4_has_syntax (M4SYNTAX, *text, M4_SYNTAX_LQUOTE)); break; case M4_TOKEN_WORD: { - const char *textp = text; - size_t len = m4_get_symbol_value_len (token); - size_t len2 = len; - - if (m4_has_syntax (M4SYNTAX, *textp, M4_SYNTAX_ESCAPE)) - { - textp++; - len2--; - } - - symbol = m4_symbol_lookup (M4SYMTAB, textp, len2); - assert (!symbol || !m4_is_symbol_void (symbol)); - if (symbol == NULL - || (symbol->value->type == M4_SYMBOL_FUNC - && BIT_TEST (SYMBOL_FLAGS (symbol), VALUE_BLIND_ARGS_BIT) - && !m4__next_token_is_open (context))) - { - m4_divert_text (context, obs, text, len, line); - /* If safe_quotes is true, then words do not overlap with - quote delimiters. If it is false, we give the - conservative answer of false rather than prove that no - multi-byte delimiters are formed. */ - return m4__safe_quotes (M4SYNTAX); - } - expand_macro (context, textp, len2, symbol); - /* Expanding a macro may create new tokens to scan, and those - tokens may generate unsafe text, but we did not append any - text now. */ - return true; + const char *textp = text; + size_t len = m4_get_symbol_value_len (token); + size_t len2 = len; + + if (m4_has_syntax (M4SYNTAX, *textp, M4_SYNTAX_ESCAPE)) + { + textp++; + len2--; + } + + symbol = m4_symbol_lookup (M4SYMTAB, textp, len2); + assert (!symbol || !m4_is_symbol_void (symbol)); + if (symbol == NULL + || (symbol->value->type == M4_SYMBOL_FUNC + && BIT_TEST (SYMBOL_FLAGS (symbol), VALUE_BLIND_ARGS_BIT) + && !m4__next_token_is_open (context))) + { + m4_divert_text (context, obs, text, len, line); + /* If safe_quotes is true, then words do not overlap with + quote delimiters. If it is false, we give the + conservative answer of false rather than prove that no + multi-byte delimiters are formed. */ + return m4__safe_quotes (M4SYNTAX); + } + expand_macro (context, textp, len2, symbol); + /* Expanding a macro may create new tokens to scan, and those + tokens may generate unsafe text, but we did not append any + text now. */ + return true; } default: @@ -303,7 +303,7 @@ expand_token (m4 *context, m4_obstack *obs, m4__token_type type, Report errors on behalf of CALLER. */ static bool expand_argument (m4 *context, m4_obstack *obs, m4_symbol_value *argp, - const m4_call_info *caller) + const m4_call_info *caller) { m4__token_type type; m4_symbol_value token; @@ -326,108 +326,108 @@ expand_argument (m4 *context, m4_obstack *obs, m4_symbol_value *argp, while (1) { if (VALUE_MIN_ARGS (argp) < VALUE_MIN_ARGS (&token)) - VALUE_MIN_ARGS (argp) = VALUE_MIN_ARGS (&token); + VALUE_MIN_ARGS (argp) = VALUE_MIN_ARGS (&token); if (VALUE_MAX_ARGS (&token) < VALUE_MAX_ARGS (argp)) - VALUE_MAX_ARGS (argp) = VALUE_MAX_ARGS (&token); + VALUE_MAX_ARGS (argp) = VALUE_MAX_ARGS (&token); switch (type) - { /* TOKSW */ - case M4_TOKEN_COMMA: - case M4_TOKEN_CLOSE: - if (paren_level == 0) - { - assert (argp->type != M4_SYMBOL_FUNC); - if (argp->type != M4_SYMBOL_COMP) - { - len = obstack_object_size (obs); - VALUE_MODULE (argp) = NULL; - if (len) - { - obstack_1grow (obs, '\0'); - m4_set_symbol_value_text (argp, obstack_finish (obs), - len, age); - } - else - m4_set_symbol_value_text (argp, "", len, 0); - } - else - { - m4__make_text_link (obs, NULL, &argp->u.u_c.end); - if (argp->u.u_c.chain == argp->u.u_c.end - && argp->u.u_c.chain->type == M4__CHAIN_FUNC) - { - const m4__builtin *func = argp->u.u_c.chain->u.builtin; - argp->type = M4_SYMBOL_FUNC; - argp->u.builtin = func; - } - } - return type == M4_TOKEN_COMMA; - } - /* fallthru */ - case M4_TOKEN_OPEN: - case M4_TOKEN_SIMPLE: - if (type == M4_TOKEN_OPEN) - paren_level++; - else if (type == M4_TOKEN_CLOSE) - paren_level--; - if (!expand_token (context, obs, type, &token, line, first)) - age = 0; - break; - - case M4_TOKEN_EOF: - m4_error (context, EXIT_FAILURE, 0, caller, - _("end of file in argument list")); - break; - - case M4_TOKEN_WORD: - case M4_TOKEN_SPACE: - case M4_TOKEN_STRING: - case M4_TOKEN_COMMENT: - case M4_TOKEN_MACDEF: - if (!expand_token (context, obs, type, &token, line, first)) - age = 0; - if (token.type == M4_SYMBOL_COMP) - { - if (argp->type != M4_SYMBOL_COMP) - { - argp->type = M4_SYMBOL_COMP; - argp->u.u_c.chain = token.u.u_c.chain; - argp->u.u_c.wrapper = argp->u.u_c.has_func = false; - } - else - { - assert (argp->u.u_c.end); - argp->u.u_c.end->next = token.u.u_c.chain; - } - argp->u.u_c.end = token.u.u_c.end; - if (token.u.u_c.has_func) - argp->u.u_c.has_func = true; - } - break; - - case M4_TOKEN_ARGV: - assert (paren_level == 0 && argp->type == M4_SYMBOL_VOID - && obstack_object_size (obs) == 0 - && token.u.u_c.chain == token.u.u_c.end - && token.u.u_c.chain->quote_age == age - && token.u.u_c.chain->type == M4__CHAIN_ARGV); - argp->type = M4_SYMBOL_COMP; - argp->u.u_c.chain = argp->u.u_c.end = token.u.u_c.chain; - argp->u.u_c.wrapper = true; - argp->u.u_c.has_func = token.u.u_c.has_func; - type = m4__next_token (context, &token, NULL, NULL, false, caller); - if (argp->u.u_c.chain->u.u_a.skip_last) - assert (type == M4_TOKEN_COMMA); - else - assert (type == M4_TOKEN_COMMA || type == M4_TOKEN_CLOSE); - return type == M4_TOKEN_COMMA; - - default: - assert (!"expand_argument"); - abort (); - } + { /* TOKSW */ + case M4_TOKEN_COMMA: + case M4_TOKEN_CLOSE: + if (paren_level == 0) + { + assert (argp->type != M4_SYMBOL_FUNC); + if (argp->type != M4_SYMBOL_COMP) + { + len = obstack_object_size (obs); + VALUE_MODULE (argp) = NULL; + if (len) + { + obstack_1grow (obs, '\0'); + m4_set_symbol_value_text (argp, obstack_finish (obs), + len, age); + } + else + m4_set_symbol_value_text (argp, "", len, 0); + } + else + { + m4__make_text_link (obs, NULL, &argp->u.u_c.end); + if (argp->u.u_c.chain == argp->u.u_c.end + && argp->u.u_c.chain->type == M4__CHAIN_FUNC) + { + const m4__builtin *func = argp->u.u_c.chain->u.builtin; + argp->type = M4_SYMBOL_FUNC; + argp->u.builtin = func; + } + } + return type == M4_TOKEN_COMMA; + } + /* fallthru */ + case M4_TOKEN_OPEN: + case M4_TOKEN_SIMPLE: + if (type == M4_TOKEN_OPEN) + paren_level++; + else if (type == M4_TOKEN_CLOSE) + paren_level--; + if (!expand_token (context, obs, type, &token, line, first)) + age = 0; + break; + + case M4_TOKEN_EOF: + m4_error (context, EXIT_FAILURE, 0, caller, + _("end of file in argument list")); + break; + + case M4_TOKEN_WORD: + case M4_TOKEN_SPACE: + case M4_TOKEN_STRING: + case M4_TOKEN_COMMENT: + case M4_TOKEN_MACDEF: + if (!expand_token (context, obs, type, &token, line, first)) + age = 0; + if (token.type == M4_SYMBOL_COMP) + { + if (argp->type != M4_SYMBOL_COMP) + { + argp->type = M4_SYMBOL_COMP; + argp->u.u_c.chain = token.u.u_c.chain; + argp->u.u_c.wrapper = argp->u.u_c.has_func = false; + } + else + { + assert (argp->u.u_c.end); + argp->u.u_c.end->next = token.u.u_c.chain; + } + argp->u.u_c.end = token.u.u_c.end; + if (token.u.u_c.has_func) + argp->u.u_c.has_func = true; + } + break; + + case M4_TOKEN_ARGV: + assert (paren_level == 0 && argp->type == M4_SYMBOL_VOID + && obstack_object_size (obs) == 0 + && token.u.u_c.chain == token.u.u_c.end + && token.u.u_c.chain->quote_age == age + && token.u.u_c.chain->type == M4__CHAIN_ARGV); + argp->type = M4_SYMBOL_COMP; + argp->u.u_c.chain = argp->u.u_c.end = token.u.u_c.chain; + argp->u.u_c.wrapper = true; + argp->u.u_c.has_func = token.u.u_c.has_func; + type = m4__next_token (context, &token, NULL, NULL, false, caller); + if (argp->u.u_c.chain->u.u_a.skip_last) + assert (type == M4_TOKEN_COMMA); + else + assert (type == M4_TOKEN_COMMA || type == M4_TOKEN_CLOSE); + return type == M4_TOKEN_COMMA; + + default: + assert (!"expand_argument"); + abort (); + } if (argp->type != M4_SYMBOL_VOID || obstack_object_size (obs)) - first = false; + first = false; type = m4__next_token (context, &token, NULL, obs, first, caller); } } @@ -463,11 +463,11 @@ expand_macro (m4 *context, const char *name, size_t len, m4_symbol *symbol) { size_t count = context->stacks_count; context->arg_stacks - = (m4__macro_arg_stacks *) x2nrealloc (context->arg_stacks, - &context->stacks_count, - sizeof *context->arg_stacks); + = (m4__macro_arg_stacks *) x2nrealloc (context->arg_stacks, + &context->stacks_count, + sizeof *context->arg_stacks); memset (&context->arg_stacks[count], 0, - sizeof *context->arg_stacks * (context->stacks_count - count)); + sizeof *context->arg_stacks * (context->stacks_count - count)); } stack = &context->arg_stacks[level]; if (!stack->args) @@ -481,7 +481,7 @@ expand_macro (m4 *context, const char *name, size_t len, m4_symbol *symbol) stack->argv_base = obstack_finish (stack->argv); } assert (obstack_object_size (stack->args) == 0 - && obstack_object_size (stack->argv) == 0); + && obstack_object_size (stack->argv) == 0); args_base = obstack_finish (stack->args); argv_base = obstack_finish (stack->argv); m4__adjust_refcount (context, level, true); @@ -495,7 +495,7 @@ expand_macro (m4 *context, const char *name, size_t len, m4_symbol *symbol) info.line = m4_get_current_line (context); info.call_id = ++macro_call_id; info.trace = (m4_is_debug_bit (context, M4_DEBUG_TRACE_ALL) - || m4_get_symbol_traced (symbol)); + || m4_get_symbol_traced (symbol)); info.debug_level = m4_get_debug_level_opt (context); info.name = name; info.name_len = len; @@ -505,7 +505,7 @@ expand_macro (m4 *context, const char *name, size_t len, m4_symbol *symbol) if (m4_get_nesting_limit_opt (context) < ++context->expansion_level) m4_error (context, EXIT_FAILURE, 0, NULL, _("\ recursion limit of %zu exceeded, use -L<N> to change it"), - m4_get_nesting_limit_opt (context)); + m4_get_nesting_limit_opt (context)); m4_trace_prepare (context, &info, value); argv = collect_arguments (context, &info, symbol, stack->args, stack->argv); @@ -537,20 +537,20 @@ recursion limit of %zu exceeded, use -L<N> to change it"), if (stack->refcount) { if (argv->inuse) - { - obstack_free (stack->args, args_scratch); - if (debug_macro_level & PRINT_ARGCOUNT_CHANGES) - xfprintf (stderr, "m4debug: -%zu- `%s' in use, level=%zu, " - "refcount=%zu, argcount=%zu\n", info.call_id, - argv->info->name, level, stack->refcount, - stack->argcount); - } + { + obstack_free (stack->args, args_scratch); + if (debug_macro_level & PRINT_ARGCOUNT_CHANGES) + xfprintf (stderr, "m4debug: -%zu- `%s' in use, level=%zu, " + "refcount=%zu, argcount=%zu\n", info.call_id, + argv->info->name, level, stack->refcount, + stack->argcount); + } else - { - obstack_free (stack->args, args_base); - obstack_free (stack->argv, argv_base); - stack->argcount--; - } + { + obstack_free (stack->args, args_base); + obstack_free (stack->argv, argv_base); + stack->argcount--; + } } } @@ -560,7 +560,7 @@ recursion limit of %zu exceeded, use -L<N> to change it"), object describing all of the macro arguments. */ static m4_macro_args * collect_arguments (m4 *context, m4_call_info *info, m4_symbol *symbol, - m4_obstack *arguments, m4_obstack *argv_stack) + m4_obstack *arguments, m4_obstack *argv_stack) { m4_symbol_value token; m4_symbol_value *tokenp; @@ -588,53 +588,53 @@ collect_arguments (m4 *context, m4_call_info *info, m4_symbol *symbol, /* Gobble parenthesis, then collect arguments. */ m4__next_token (context, &token, NULL, NULL, false, info); do - { - tokenp = (m4_symbol_value *) obstack_alloc (arguments, - sizeof *tokenp); - more_args = expand_argument (context, arguments, tokenp, info); - - if ((m4_is_symbol_value_text (tokenp) - && !m4_get_symbol_value_len (tokenp)) - || (args.flatten && m4_is_symbol_value_func (tokenp))) - { - obstack_free (arguments, tokenp); - tokenp = &empty_symbol; - } - obstack_ptr_grow (argv_stack, tokenp); - args.arraylen++; - args.argc++; - switch (tokenp->type) - { - case M4_SYMBOL_TEXT: - /* Be conservative - any change in quoting while - collecting arguments, or any unsafe argument, will - require a rescan if $@ is reused. */ - if (m4_get_symbol_value_len (tokenp) - && m4_get_symbol_value_quote_age (tokenp) != args.quote_age) - args.quote_age = 0; - break; - case M4_SYMBOL_FUNC: - args.has_func = true; - break; - case M4_SYMBOL_COMP: - args.has_ref = true; - if (tokenp->u.u_c.wrapper) - { - assert (tokenp->u.u_c.chain->type == M4__CHAIN_ARGV - && !tokenp->u.u_c.chain->next); - args.argc += (tokenp->u.u_c.chain->u.u_a.argv->argc - - tokenp->u.u_c.chain->u.u_a.index - - tokenp->u.u_c.chain->u.u_a.skip_last - 1); - args.wrapper = true; - } - if (tokenp->u.u_c.has_func) - args.has_func = true; - break; - default: - assert (!"expand_argument"); - abort (); - } - } + { + tokenp = (m4_symbol_value *) obstack_alloc (arguments, + sizeof *tokenp); + more_args = expand_argument (context, arguments, tokenp, info); + + if ((m4_is_symbol_value_text (tokenp) + && !m4_get_symbol_value_len (tokenp)) + || (args.flatten && m4_is_symbol_value_func (tokenp))) + { + obstack_free (arguments, tokenp); + tokenp = &empty_symbol; + } + obstack_ptr_grow (argv_stack, tokenp); + args.arraylen++; + args.argc++; + switch (tokenp->type) + { + case M4_SYMBOL_TEXT: + /* Be conservative - any change in quoting while + collecting arguments, or any unsafe argument, will + require a rescan if $@ is reused. */ + if (m4_get_symbol_value_len (tokenp) + && m4_get_symbol_value_quote_age (tokenp) != args.quote_age) + args.quote_age = 0; + break; + case M4_SYMBOL_FUNC: + args.has_func = true; + break; + case M4_SYMBOL_COMP: + args.has_ref = true; + if (tokenp->u.u_c.wrapper) + { + assert (tokenp->u.u_c.chain->type == M4__CHAIN_ARGV + && !tokenp->u.u_c.chain->next); + args.argc += (tokenp->u.u_c.chain->u.u_a.argv->argc + - tokenp->u.u_c.chain->u.u_a.index + - tokenp->u.u_c.chain->u.u_a.skip_last - 1); + args.wrapper = true; + } + if (tokenp->u.u_c.has_func) + args.has_func = true; + break; + default: + assert (!"expand_argument"); + abort (); + } + } while (more_args); } argv = (m4_macro_args *) obstack_finish (argv_stack); @@ -657,32 +657,32 @@ collect_arguments (m4 *context, m4_call_info *info, m4_symbol *symbol, tracing is also handled here. */ void m4_macro_call (m4 *context, m4_symbol_value *value, m4_obstack *expansion, - m4_macro_args *argv) + m4_macro_args *argv) { unsigned int trace_start = 0; if (argv->info->trace) trace_start = trace_pre (context, argv); if (!m4_bad_argc (context, argv->argc, argv->info, - VALUE_MIN_ARGS (value), VALUE_MAX_ARGS (value), - BIT_TEST (VALUE_FLAGS (value), - VALUE_SIDE_EFFECT_ARGS_BIT))) + VALUE_MIN_ARGS (value), VALUE_MAX_ARGS (value), + BIT_TEST (VALUE_FLAGS (value), + VALUE_SIDE_EFFECT_ARGS_BIT))) { if (m4_is_symbol_value_text (value)) - process_macro (context, value, expansion, argv->argc, argv); + process_macro (context, value, expansion, argv->argc, argv); else if (m4_is_symbol_value_func (value)) - m4_get_symbol_value_func (value) (context, expansion, argv->argc, - argv); + m4_get_symbol_value_func (value) (context, expansion, argv->argc, + argv); else if (m4_is_symbol_value_placeholder (value)) - m4_warn (context, 0, argv->info, - _("builtin %s requested by frozen file not found"), - quotearg_style (locale_quoting_style, - m4_get_symbol_value_placeholder (value))); + m4_warn (context, 0, argv->info, + _("builtin %s requested by frozen file not found"), + quotearg_style (locale_quoting_style, + m4_get_symbol_value_placeholder (value))); else - { - assert (!"m4_macro_call"); - abort (); - } + { + assert (!"m4_macro_call"); + abort (); + } } if (argv->info->trace) trace_post (context, trace_start, argv->info); @@ -695,7 +695,7 @@ m4_macro_call (m4 *context, m4_symbol_value *value, m4_obstack *expansion, as usual. */ static void process_macro (m4 *context, m4_symbol_value *value, m4_obstack *obs, - int argc, m4_macro_args *argv) + int argc, m4_macro_args *argv) { const char *text = m4_get_symbol_value_text (value); size_t len = m4_get_symbol_value_len (value); @@ -705,121 +705,121 @@ process_macro (m4 *context, m4_symbol_value *value, m4_obstack *obs, { const char *dollar; if (m4_is_syntax_single_dollar (M4SYNTAX)) - dollar = (char *) memchr (text, M4SYNTAX->dollar, len); + dollar = (char *) memchr (text, M4SYNTAX->dollar, len); else - { - dollar = text; - while (dollar != end) - { - if (m4_has_syntax (M4SYNTAX, *dollar, M4_SYNTAX_DOLLAR)) - break; - dollar++; - } - if (dollar == end) - dollar = NULL; - } + { + dollar = text; + while (dollar != end) + { + if (m4_has_syntax (M4SYNTAX, *dollar, M4_SYNTAX_DOLLAR)) + break; + dollar++; + } + if (dollar == end) + dollar = NULL; + } if (!dollar) - { - obstack_grow (obs, text, len); - return; - } + { + obstack_grow (obs, text, len); + return; + } obstack_grow (obs, text, dollar - text); len -= dollar - text; text = dollar; if (len == 1) - { - obstack_1grow (obs, *dollar); - return; - } + { + obstack_1grow (obs, *dollar); + return; + } len--; switch (*++text) - { - case '0': case '1': case '2': case '3': case '4': - case '5': case '6': case '7': case '8': case '9': - /* FIXME - multidigit arguments should convert over to ${10} - syntax instead of $10; see - http://lists.gnu.org/archive/html/m4-discuss/2006-08/msg00028.html - for more discussion. */ - if (m4_get_posixly_correct_opt (context) - || !isdigit (to_uchar (text[1]))) - { - i = *text++ - '0'; - len--; - } - else - { - char *endp; - i = (int) strtol (text, &endp, 10); - len -= endp - text; - text = endp; - } - if (i < argc) - m4_push_arg (context, obs, argv, i); - break; - - case '#': /* number of arguments */ - m4_shipout_int (obs, argc - 1); - text++; - len--; - break; - - case '*': /* all arguments */ - case '@': /* ... same, but quoted */ - m4_push_args (context, obs, argv, false, *text == '@'); - text++; - len--; - break; - - default: - if (m4_get_posixly_correct_opt (context) - || !VALUE_ARG_SIGNATURE (value)) - { - obstack_1grow (obs, *dollar); - } - else - { - size_t len1 = 0; - const char *endp; - char *key; - - for (endp = ++text; - len1 < len && m4_has_syntax (M4SYNTAX, *endp, - (M4_SYNTAX_OTHER - | M4_SYNTAX_ALPHA - | M4_SYNTAX_NUM)); - ++endp) - { - ++len1; - } - key = xstrndup (text, len1); - - if (*endp) - { - struct m4_symbol_arg **arg - = (struct m4_symbol_arg **) - m4_hash_lookup (VALUE_ARG_SIGNATURE (value), key); - - if (arg) - { - i = SYMBOL_ARG_INDEX (*arg); - assert (i < argc); - m4_shipout_string (context, obs, M4ARG (i), M4ARGLEN (i), - false); - } - } - else - { - m4_error (context, 0, 0, argv->info, - _("unterminated parameter reference: %s"), key); - } - - len -= endp - text; - text = endp; - - free (key); - } - break; - } + { + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': + /* FIXME - multidigit arguments should convert over to ${10} + syntax instead of $10; see + http://lists.gnu.org/archive/html/m4-discuss/2006-08/msg00028.html + for more discussion. */ + if (m4_get_posixly_correct_opt (context) + || !isdigit (to_uchar (text[1]))) + { + i = *text++ - '0'; + len--; + } + else + { + char *endp; + i = (int) strtol (text, &endp, 10); + len -= endp - text; + text = endp; + } + if (i < argc) + m4_push_arg (context, obs, argv, i); + break; + + case '#': /* number of arguments */ + m4_shipout_int (obs, argc - 1); + text++; + len--; + break; + + case '*': /* all arguments */ + case '@': /* ... same, but quoted */ + m4_push_args (context, obs, argv, false, *text == '@'); + text++; + len--; + break; + + default: + if (m4_get_posixly_correct_opt (context) + || !VALUE_ARG_SIGNATURE (value)) + { + obstack_1grow (obs, *dollar); + } + else + { + size_t len1 = 0; + const char *endp; + char *key; + + for (endp = ++text; + len1 < len && m4_has_syntax (M4SYNTAX, *endp, + (M4_SYNTAX_OTHER + | M4_SYNTAX_ALPHA + | M4_SYNTAX_NUM)); + ++endp) + { + ++len1; + } + key = xstrndup (text, len1); + + if (*endp) + { + struct m4_symbol_arg **arg + = (struct m4_symbol_arg **) + m4_hash_lookup (VALUE_ARG_SIGNATURE (value), key); + + if (arg) + { + i = SYMBOL_ARG_INDEX (*arg); + assert (i < argc); + m4_shipout_string (context, obs, M4ARG (i), M4ARGLEN (i), + false); + } + } + else + { + m4_error (context, 0, 0, argv->info, + _("unterminated parameter reference: %s"), key); + } + + len -= endp - text; + text = endp; + + free (key); + } + break; + } } } @@ -873,7 +873,7 @@ trace_flush (m4 *context, unsigned int start) Should be called prior to m4_macro_call(). */ void m4_trace_prepare (m4 *context, const m4_call_info *info, - m4_symbol_value *value) + m4_symbol_value *value) { const m4_string_pair *quotes = NULL; size_t arg_length = m4_get_max_debug_arg_length_opt (context); @@ -887,7 +887,7 @@ m4_trace_prepare (m4 *context, const m4_call_info *info, obstack_grow (&context->trace_messages, info->name, info->name_len); obstack_grow (&context->trace_messages, " ... = ", 7); m4__symbol_value_print (context, value, &context->trace_messages, quotes, - false, NULL, &arg_length, module); + false, NULL, &arg_length, module); trace_flush (context, start); } } @@ -913,10 +913,10 @@ trace_pre (m4 *context, m4_macro_args *argv) bool module = (trace_level & M4_DEBUG_TRACE_MODULE) != 0; if (trace_level & M4_DEBUG_TRACE_QUOTE) - quotes = m4_get_syntax_quotes (M4SYNTAX); + quotes = m4_get_syntax_quotes (M4SYNTAX); obstack_1grow (trace, '('); m4__arg_print (context, trace, argv, 1, quotes, false, NULL, ", ", - &arg_length, true, module); + &arg_length, true, module); obstack_1grow (trace, ')'); } return start; @@ -949,7 +949,7 @@ m4__adjust_refcount (m4 *context, size_t level, bool increase) { m4__macro_arg_stacks *stack = &context->arg_stacks[level]; assert (level < context->stacks_count && stack->args - && (increase || stack->refcount)); + && (increase || stack->refcount)); if (increase) stack->refcount++; else if (--stack->refcount == 0) @@ -957,14 +957,14 @@ m4__adjust_refcount (m4 *context, size_t level, bool increase) obstack_free (stack->args, stack->args_base); obstack_free (stack->argv, stack->argv_base); if ((debug_macro_level & PRINT_ARGCOUNT_CHANGES) && 1 < stack->argcount) - xfprintf (stderr, "m4debug: -%zu- freeing %zu args, level=%zu\n", - macro_call_id, stack->argcount, level); + xfprintf (stderr, "m4debug: -%zu- freeing %zu args, level=%zu\n", + macro_call_id, stack->argcount, level); stack->argcount = 0; } if (debug_macro_level & (increase ? PRINT_REFCOUNT_INCREASE : PRINT_REFCOUNT_DECREASE)) xfprintf (stderr, "m4debug: level %zu refcount=%zu\n", level, - stack->refcount); + stack->refcount); return stack->refcount; } @@ -981,31 +981,31 @@ m4__arg_adjust_refcount (m4 *context, m4_macro_args *argv, bool increase) if (argv->has_ref) for (i = 0; i < argv->arraylen; i++) if (argv->array[i]->type == M4_SYMBOL_COMP) - { - chain = argv->array[i]->u.u_c.chain; - while (chain) - { - switch (chain->type) - { - case M4__CHAIN_STR: - if (chain->u.u_s.level < SIZE_MAX) - m4__adjust_refcount (context, chain->u.u_s.level, - increase); - break; - case M4__CHAIN_FUNC: - break; - case M4__CHAIN_ARGV: - assert (chain->u.u_a.argv->inuse); - m4__arg_adjust_refcount (context, chain->u.u_a.argv, - increase); - break; - default: - assert (!"m4__arg_adjust_refcount"); - abort (); - } - chain = chain->next; - } - } + { + chain = argv->array[i]->u.u_c.chain; + while (chain) + { + switch (chain->type) + { + case M4__CHAIN_STR: + if (chain->u.u_s.level < SIZE_MAX) + m4__adjust_refcount (context, chain->u.u_s.level, + increase); + break; + case M4__CHAIN_FUNC: + break; + case M4__CHAIN_ARGV: + assert (chain->u.u_a.argv->inuse); + m4__arg_adjust_refcount (context, chain->u.u_a.argv, + increase); + break; + default: + assert (!"m4__arg_adjust_refcount"); + abort (); + } + chain = chain->next; + } + } m4__adjust_refcount (context, argv->level, increase); return result; } @@ -1024,14 +1024,14 @@ arg_mark (m4_macro_args *argv) if (argv->wrapper) { for (i = 0; i < argv->arraylen; i++) - if (argv->array[i]->type == M4_SYMBOL_COMP - && argv->array[i]->u.u_c.wrapper) - { - chain = argv->array[i]->u.u_c.chain; - assert (!chain->next && chain->type == M4__CHAIN_ARGV); - if (!chain->u.u_a.argv->inuse) - arg_mark (chain->u.u_a.argv); - } + if (argv->array[i]->type == M4_SYMBOL_COMP + && argv->array[i]->u.u_c.wrapper) + { + chain = argv->array[i]->u.u_c.chain; + assert (!chain->next && chain->type == M4__CHAIN_ARGV); + if (!chain->u.u_a.argv->inuse) + arg_mark (chain->u.u_a.argv); + } } } @@ -1043,8 +1043,8 @@ arg_mark (m4_macro_args *argv) empty. */ static m4_symbol_value * make_argv_ref (m4 *context, m4_symbol_value *value, m4_obstack *obs, - size_t level, m4_macro_args *argv, size_t arg, bool flatten, - const m4_string_pair *quotes) + size_t level, m4_macro_args *argv, size_t arg, bool flatten, + const m4_string_pair *quotes) { m4__symbol_chain *chain; @@ -1060,36 +1060,36 @@ make_argv_ref (m4 *context, m4_symbol_value *value, m4_obstack *obs, { size_t i; for (i = 0; i < argv->arraylen; i++) - { - if ((argv->array[i]->type == M4_SYMBOL_COMP - && argv->array[i]->u.u_c.wrapper) - || level < SIZE_MAX) - break; - if (arg == 1) - { - m4__push_arg_quote (context, obs, argv, i + 1, quotes); - /* TODO support M4_SYNTAX_COMMA. */ - obstack_1grow (obs, ','); - } - else - arg--; - } + { + if ((argv->array[i]->type == M4_SYMBOL_COMP + && argv->array[i]->u.u_c.wrapper) + || level < SIZE_MAX) + break; + if (arg == 1) + { + m4__push_arg_quote (context, obs, argv, i + 1, quotes); + /* TODO support M4_SYNTAX_COMMA. */ + obstack_1grow (obs, ','); + } + else + arg--; + } assert (i < argv->arraylen); if (i + 1 == argv->arraylen) - { - assert (argv->array[i]->type == M4_SYMBOL_COMP - && argv->array[i]->u.u_c.wrapper); - chain = argv->array[i]->u.u_c.chain; - assert (!chain->next && chain->type == M4__CHAIN_ARGV - && !chain->u.u_a.skip_last); - argv = chain->u.u_a.argv; - arg += chain->u.u_a.index - 1; - } + { + assert (argv->array[i]->type == M4_SYMBOL_COMP + && argv->array[i]->u.u_c.wrapper); + chain = argv->array[i]->u.u_c.chain; + assert (!chain->next && chain->type == M4__CHAIN_ARGV + && !chain->u.u_a.skip_last); + argv = chain->u.u_a.argv; + arg += chain->u.u_a.index - 1; + } else - { - arg += i; - break; - } + { + arg += i; + break; + } } m4__make_text_link (obs, &value->u.u_c.chain, &value->u.u_c.end); @@ -1111,7 +1111,7 @@ make_argv_ref (m4 *context, m4_symbol_value *value, m4_obstack *obs, chain->u.u_a.comma = false; chain->u.u_a.skip_last = false; chain->u.u_a.quotes = m4__quote_cache (M4SYNTAX, obs, chain->quote_age, - quotes); + quotes); return value; } @@ -1135,7 +1135,7 @@ arg_symbol (m4_macro_args *argv, size_t arg, size_t *level, bool flatten) { value = argv->array[arg - 1]; if (flatten && m4_is_symbol_value_func (value)) - value = &empty_symbol; + value = &empty_symbol; return value; } @@ -1145,22 +1145,22 @@ arg_symbol (m4_macro_args *argv, size_t arg, size_t *level, bool flatten) { value = argv->array[i]; if (value->type == M4_SYMBOL_COMP && value->u.u_c.wrapper) - { - m4__symbol_chain *chain = value->u.u_c.chain; - assert (!chain->next && chain->type == M4__CHAIN_ARGV); - if (arg <= (chain->u.u_a.argv->argc - chain->u.u_a.index - - chain->u.u_a.skip_last)) - { - value = arg_symbol (chain->u.u_a.argv, - chain->u.u_a.index - 1 + arg, level, - flatten || chain->u.u_a.flatten); - break; - } - arg -= (chain->u.u_a.argv->argc - chain->u.u_a.index - - chain->u.u_a.skip_last); - } + { + m4__symbol_chain *chain = value->u.u_c.chain; + assert (!chain->next && chain->type == M4__CHAIN_ARGV); + if (arg <= (chain->u.u_a.argv->argc - chain->u.u_a.index + - chain->u.u_a.skip_last)) + { + value = arg_symbol (chain->u.u_a.argv, + chain->u.u_a.index - 1 + arg, level, + flatten || chain->u.u_a.flatten); + break; + } + arg -= (chain->u.u_a.argv->argc - chain->u.u_a.index + - chain->u.u_a.skip_last); + } else if (--arg == 0) - break; + break; } return value; } @@ -1242,27 +1242,27 @@ m4_arg_text (m4 *context, m4_macro_args *argv, size_t arg, bool flatten) while (chain) { switch (chain->type) - { - case M4__CHAIN_STR: - obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len); - break; - case M4__CHAIN_FUNC: - if (flatten) - break; - assert (!"m4_arg_text"); - abort (); - case M4__CHAIN_ARGV: - assert (!chain->u.u_a.has_func || flatten || argv->flatten); - m4__arg_print (context, obs, chain->u.u_a.argv, chain->u.u_a.index, - m4__quote_cache (M4SYNTAX, NULL, chain->quote_age, - chain->u.u_a.quotes), - flatten || argv->flatten || chain->u.u_a.flatten, - NULL, NULL, NULL, false, false); - break; - default: - assert (!"m4_arg_text"); - abort (); - } + { + case M4__CHAIN_STR: + obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len); + break; + case M4__CHAIN_FUNC: + if (flatten) + break; + assert (!"m4_arg_text"); + abort (); + case M4__CHAIN_ARGV: + assert (!chain->u.u_a.has_func || flatten || argv->flatten); + m4__arg_print (context, obs, chain->u.u_a.argv, chain->u.u_a.index, + m4__quote_cache (M4SYNTAX, NULL, chain->quote_age, + chain->u.u_a.quotes), + flatten || argv->flatten || chain->u.u_a.flatten, + NULL, NULL, NULL, false, false); + break; + default: + assert (!"m4_arg_text"); + abort (); + } chain = chain->next; } obstack_1grow (obs, '\0'); @@ -1273,7 +1273,7 @@ m4_arg_text (m4 *context, m4_macro_args *argv, size_t arg, bool flatten) Both indices must be non-zero. Return true if the arguments contain the same contents; often more efficient than !strcmp (m4_arg_text (context, argv, indexa), - m4_arg_text (context, argv, indexb)). */ + m4_arg_text (context, argv, indexb)). */ bool m4_arg_equal (m4 *context, m4_macro_args *argv, size_t indexa, size_t indexb) { @@ -1291,9 +1291,9 @@ m4_arg_equal (m4 *context, m4_macro_args *argv, size_t indexa, size_t indexb) return sa == sb; if (m4_is_symbol_value_text (sa) && m4_is_symbol_value_text (sb)) return (m4_get_symbol_value_len (sa) == m4_get_symbol_value_len (sb) - && memcmp (m4_get_symbol_value_text (sa), - m4_get_symbol_value_text (sb), - m4_get_symbol_value_len (sa)) == 0); + && memcmp (m4_get_symbol_value_text (sa), + m4_get_symbol_value_text (sb), + m4_get_symbol_value_len (sa)) == 0); /* Convert both arguments to chains, if not one already. */ switch (sa->type) @@ -1341,76 +1341,76 @@ m4_arg_equal (m4 *context, m4_macro_args *argv, size_t indexa, size_t indexb) while (ca && cb) { if (ca->type == M4__CHAIN_ARGV) - { - tmpa.next = NULL; - tmpa.type = M4__CHAIN_STR; - tmpa.u.u_s.str = NULL; - tmpa.u.u_s.len = 0; - chain = &tmpa; - m4__arg_print (context, obs, ca->u.u_a.argv, ca->u.u_a.index, - m4__quote_cache (M4SYNTAX, NULL, ca->quote_age, - ca->u.u_a.quotes), - argv->flatten || ca->u.u_a.flatten, &chain, NULL, - NULL, false, false); - assert (obstack_object_size (obs) == 0 && chain != &tmpa); - chain->next = ca->next; - ca = tmpa.next; - continue; - } + { + tmpa.next = NULL; + tmpa.type = M4__CHAIN_STR; + tmpa.u.u_s.str = NULL; + tmpa.u.u_s.len = 0; + chain = &tmpa; + m4__arg_print (context, obs, ca->u.u_a.argv, ca->u.u_a.index, + m4__quote_cache (M4SYNTAX, NULL, ca->quote_age, + ca->u.u_a.quotes), + argv->flatten || ca->u.u_a.flatten, &chain, NULL, + NULL, false, false); + assert (obstack_object_size (obs) == 0 && chain != &tmpa); + chain->next = ca->next; + ca = tmpa.next; + continue; + } if (cb->type == M4__CHAIN_ARGV) - { - tmpb.next = NULL; - tmpb.type = M4__CHAIN_STR; - tmpb.u.u_s.str = NULL; - tmpb.u.u_s.len = 0; - chain = &tmpb; - m4__arg_print (context, obs, cb->u.u_a.argv, cb->u.u_a.index, - m4__quote_cache (M4SYNTAX, NULL, cb->quote_age, - cb->u.u_a.quotes), - argv->flatten || cb->u.u_a.flatten, &chain, NULL, - NULL, false, false); - assert (obstack_object_size (obs) == 0 && chain != &tmpb); - chain->next = cb->next; - cb = tmpb.next; - continue; - } + { + tmpb.next = NULL; + tmpb.type = M4__CHAIN_STR; + tmpb.u.u_s.str = NULL; + tmpb.u.u_s.len = 0; + chain = &tmpb; + m4__arg_print (context, obs, cb->u.u_a.argv, cb->u.u_a.index, + m4__quote_cache (M4SYNTAX, NULL, cb->quote_age, + cb->u.u_a.quotes), + argv->flatten || cb->u.u_a.flatten, &chain, NULL, + NULL, false, false); + assert (obstack_object_size (obs) == 0 && chain != &tmpb); + chain->next = cb->next; + cb = tmpb.next; + continue; + } if (ca->type == M4__CHAIN_FUNC) - { - if (cb->type != M4__CHAIN_FUNC || ca->u.builtin != cb->u.builtin) - return false; - ca = ca->next; - cb = cb->next; - continue; - } + { + if (cb->type != M4__CHAIN_FUNC || ca->u.builtin != cb->u.builtin) + return false; + ca = ca->next; + cb = cb->next; + continue; + } assert (ca->type == M4__CHAIN_STR && cb->type == M4__CHAIN_STR); if (ca->u.u_s.len == cb->u.u_s.len) - { - if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0) - return false; - ca = ca->next; - cb = cb->next; - } + { + if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0) + return false; + ca = ca->next; + cb = cb->next; + } else if (ca->u.u_s.len < cb->u.u_s.len) - { - if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0) - return false; - tmpb.next = cb->next; - tmpb.u.u_s.str = cb->u.u_s.str + ca->u.u_s.len; - tmpb.u.u_s.len = cb->u.u_s.len - ca->u.u_s.len; - ca = ca->next; - cb = &tmpb; - } + { + if (memcmp (ca->u.u_s.str, cb->u.u_s.str, ca->u.u_s.len) != 0) + return false; + tmpb.next = cb->next; + tmpb.u.u_s.str = cb->u.u_s.str + ca->u.u_s.len; + tmpb.u.u_s.len = cb->u.u_s.len - ca->u.u_s.len; + ca = ca->next; + cb = &tmpb; + } else - { - assert (cb->u.u_s.len < ca->u.u_s.len); - if (memcmp (ca->u.u_s.str, cb->u.u_s.str, cb->u.u_s.len) != 0) - return false; - tmpa.next = ca->next; - tmpa.u.u_s.str = ca->u.u_s.str + cb->u.u_s.len; - tmpa.u.u_s.len = ca->u.u_s.len - cb->u.u_s.len; - ca = &tmpa; - cb = cb->next; - } + { + assert (cb->u.u_s.len < ca->u.u_s.len); + if (memcmp (ca->u.u_s.str, cb->u.u_s.str, cb->u.u_s.len) != 0) + return false; + tmpa.next = ca->next; + tmpa.u.u_s.str = ca->u.u_s.str + cb->u.u_s.len; + tmpa.u.u_s.len = ca->u.u_s.len - cb->u.u_s.len; + ca = &tmpa; + cb = cb->next; + } } /* If we get this far, the two arguments are equal only if both @@ -1462,30 +1462,30 @@ m4_arg_len (m4 *context, m4_macro_args *argv, size_t arg, bool flatten) size_t limit; const m4_string_pair *quotes; switch (chain->type) - { - case M4__CHAIN_STR: - len += chain->u.u_s.len; - break; - case M4__CHAIN_FUNC: - assert (flatten); - break; - case M4__CHAIN_ARGV: - i = chain->u.u_a.index; - limit = chain->u.u_a.argv->argc - i - chain->u.u_a.skip_last; - quotes = m4__quote_cache (M4SYNTAX, NULL, chain->quote_age, - chain->u.u_a.quotes); - assert (limit); - if (quotes) - len += (quotes->len1 + quotes->len2) * limit; - len += limit - 1; - while (limit--) - len += m4_arg_len (context, chain->u.u_a.argv, i++, - flatten || chain->u.u_a.flatten); - break; - default: - assert (!"m4_arg_len"); - abort (); - } + { + case M4__CHAIN_STR: + len += chain->u.u_s.len; + break; + case M4__CHAIN_FUNC: + assert (flatten); + break; + case M4__CHAIN_ARGV: + i = chain->u.u_a.index; + limit = chain->u.u_a.argv->argc - i - chain->u.u_a.skip_last; + quotes = m4__quote_cache (M4SYNTAX, NULL, chain->quote_age, + chain->u.u_a.quotes); + assert (limit); + if (quotes) + len += (quotes->len1 + quotes->len2) * limit; + len += limit - 1; + while (limit--) + len += m4_arg_len (context, chain->u.u_a.argv, i++, + flatten || chain->u.u_a.flatten); + break; + default: + assert (!"m4_arg_len"); + abort (); + } chain = chain->next; } assert (len || flatten); @@ -1516,9 +1516,9 @@ m4_arg_func (m4_macro_args *argv, size_t arg) length. MAX_LEN and CHAINP may not both be specified. */ bool m4__arg_print (m4 *context, m4_obstack *obs, m4_macro_args *argv, size_t arg, - const m4_string_pair *quotes, bool flatten, - m4__symbol_chain **chainp, const char *sep, size_t *max_len, - bool quote_each, bool module) + const m4_string_pair *quotes, bool flatten, + m4__symbol_chain **chainp, const char *sep, size_t *max_len, + bool quote_each, bool module) { size_t len = max_len ? *max_len : SIZE_MAX; size_t i; @@ -1535,22 +1535,22 @@ m4__arg_print (m4 *context, m4_obstack *obs, m4_macro_args *argv, size_t arg, for (i = arg; i < argv->argc; i++) { if (quote_each && max_len) - len = *max_len; + len = *max_len; if (use_sep && m4_shipout_string_trunc (obs, sep, sep_len, NULL, plen)) - return true; + return true; use_sep = true; if (quotes && !quote_each - && m4_shipout_string_trunc (obs, quotes->str1, quotes->len1, NULL, - plen)) - return true; + && m4_shipout_string_trunc (obs, quotes->str1, quotes->len1, NULL, + plen)) + return true; if (m4__symbol_value_print (context, arg_symbol (argv, i, NULL, flatten), - obs, quote_each ? quotes : NULL, flatten, - chainp, &len, module)) - return true; + obs, quote_each ? quotes : NULL, flatten, + chainp, &len, module)) + return true; if (quotes && !quote_each - && m4_shipout_string_trunc (obs, quotes->str2, quotes->len2, NULL, - plen)) - return true; + && m4_shipout_string_trunc (obs, quotes->str2, quotes->len2, NULL, + plen)) + return true; } if (max_len) *max_len = len; @@ -1568,7 +1568,7 @@ m4__arg_print (m4 *context, m4_obstack *obs, m4_macro_args *argv, size_t arg, regardless of global trace state. */ m4_macro_args * m4_make_argv_ref (m4 *context, m4_macro_args *argv, const char *argv0, - size_t argv0_len, bool flatten, bool trace) + size_t argv0_len, bool flatten, bool trace) { m4_macro_args *new_argv; m4_symbol_value *value; @@ -1579,12 +1579,12 @@ m4_make_argv_ref (m4 *context, m4_macro_args *argv, const char *argv0, info = (m4_call_info *) obstack_copy (obs, argv->info, sizeof *info); new_value = (m4_symbol_value *) obstack_alloc (obs, sizeof *value); value = make_argv_ref (context, new_value, obs, context->expansion_level - 1, - argv, 2, flatten, NULL); + argv, 2, flatten, NULL); if (!value) { obstack_free (obs, new_value); new_argv = (m4_macro_args *) obstack_alloc (obs, offsetof (m4_macro_args, - array)); + array)); new_argv->arraylen = 0; new_argv->wrapper = false; new_argv->has_ref = false; @@ -1594,8 +1594,8 @@ m4_make_argv_ref (m4 *context, m4_macro_args *argv, const char *argv0, else { new_argv = (m4_macro_args *) obstack_alloc (obs, (offsetof (m4_macro_args, - array) - + sizeof value)); + array) + + sizeof value)); new_argv->arraylen = 1; new_argv->array[0] = value; new_argv->wrapper = true; @@ -1625,10 +1625,10 @@ m4_push_arg (m4 *context, m4_obstack *obs, m4_macro_args *argv, size_t arg) { assert (argv->info); m4_set_symbol_value_text (&value, argv->info->name, argv->info->name_len, - 0); + 0); if (m4__push_symbol (context, &value, context->expansion_level - 1, - argv->inuse)) - arg_mark (argv); + argv->inuse)) + arg_mark (argv); } else m4__push_arg_quote (context, obs, argv, arg, NULL); @@ -1639,7 +1639,7 @@ m4_push_arg (m4 *context, m4_obstack *obs, m4_macro_args *argv, size_t arg) delimiters that were in effect when the reference was created. */ void m4__push_arg_quote (m4 *context, m4_obstack *obs, m4_macro_args *argv, - size_t arg, const m4_string_pair *quotes) + size_t arg, const m4_string_pair *quotes) { size_t level; m4_symbol_value *value = arg_symbol (argv, arg, &level, false); @@ -1658,7 +1658,7 @@ m4__push_arg_quote (m4 *context, m4_obstack *obs, m4_macro_args *argv, first argument. If QUOTE, also push quoting around each arg. */ void m4_push_args (m4 *context, m4_obstack *obs, m4_macro_args *argv, bool skip, - bool quote) + bool quote) { m4_symbol_value tmp; m4_symbol_value *value; @@ -1675,7 +1675,7 @@ m4_push_args (m4 *context, m4_obstack *obs, m4_macro_args *argv, bool skip, } value = make_argv_ref (context, &tmp, obs, -1, argv, i, argv->flatten, - quote ? quotes : NULL); + quote ? quotes : NULL); assert (value == &tmp); if (m4__push_symbol (context, value, -1, argv->inuse)) arg_mark (argv); @@ -1701,49 +1701,49 @@ m4_wrap_args (m4 *context, m4_macro_args *argv) for (i = 1; i < limit; i++) { if (i != 1) - obstack_1grow (obs, ' '); + obstack_1grow (obs, ' '); value = m4_arg_symbol (argv, i); switch (value->type) - { - case M4_SYMBOL_TEXT: - obstack_grow (obs, m4_get_symbol_value_text (value), - m4_get_symbol_value_len (value)); - break; - case M4_SYMBOL_FUNC: - m4__append_builtin (obs, value->u.builtin, NULL, end); - break; - case M4_SYMBOL_COMP: - chain = value->u.u_c.chain; - while (chain) - { - switch (chain->type) - { - case M4__CHAIN_STR: - obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len); - break; - case M4__CHAIN_FUNC: - m4__append_builtin (obs, chain->u.builtin, NULL, end); - break; - case M4__CHAIN_ARGV: - m4__arg_print (context, obs, chain->u.u_a.argv, - chain->u.u_a.index, - m4__quote_cache (M4SYNTAX, NULL, - chain->quote_age, - chain->u.u_a.quotes), - chain->u.u_a.flatten, end, NULL, NULL, false, - false); - break; - default: - assert (!"m4_wrap_args"); - abort (); - } - chain = chain->next; - } - break; - default: - assert (!"m4_wrap_args"); - abort (); - } + { + case M4_SYMBOL_TEXT: + obstack_grow (obs, m4_get_symbol_value_text (value), + m4_get_symbol_value_len (value)); + break; + case M4_SYMBOL_FUNC: + m4__append_builtin (obs, value->u.builtin, NULL, end); + break; + case M4_SYMBOL_COMP: + chain = value->u.u_c.chain; + while (chain) + { + switch (chain->type) + { + case M4__CHAIN_STR: + obstack_grow (obs, chain->u.u_s.str, chain->u.u_s.len); + break; + case M4__CHAIN_FUNC: + m4__append_builtin (obs, chain->u.builtin, NULL, end); + break; + case M4__CHAIN_ARGV: + m4__arg_print (context, obs, chain->u.u_a.argv, + chain->u.u_a.index, + m4__quote_cache (M4SYNTAX, NULL, + chain->quote_age, + chain->u.u_a.quotes), + chain->u.u_a.flatten, end, NULL, NULL, false, + false); + break; + default: + assert (!"m4_wrap_args"); + abort (); + } + chain = chain->next; + } + break; + default: + assert (!"m4_wrap_args"); + abort (); + } } m4__push_wrapup_finish (); } |