1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 2021 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 #include "language/lexer/macro.h"
25 #include "data/settings.h"
26 #include "language/lexer/lexer.h"
27 #include "language/lexer/segment.h"
28 #include "language/lexer/scan.h"
29 #include "libpspp/assertion.h"
30 #include "libpspp/cast.h"
31 #include "libpspp/i18n.h"
32 #include "libpspp/message.h"
33 #include "libpspp/str.h"
34 #include "libpspp/string-array.h"
35 #include "libpspp/stringi-map.h"
36 #include "libpspp/stringi-set.h"
38 #include "gl/c-ctype.h"
39 #include "gl/ftoastr.h"
42 #define _(msgid) gettext (msgid)
44 /* An entry in the stack of macros and macro directives being expanded. The
45 stack is maintained as a linked list. Entries are not dynamically allocated
46 but on the program stack.
48 The outermost entry, where 'next' is NULL, represents the source location of
49 the call to the macro. */
50 struct macro_expansion_stack
52 const struct macro_expansion_stack *next; /* Next outer stack entry. */
53 const char *name; /* A macro name or !IF, !DO, etc. */
54 const struct msg_location *location; /* Source location if available. */
57 /* Reports an error during macro expansion. STACK is the stack for reporting
58 the location of the error, MT is the optional token at which the error was
59 detected, and FORMAT along with the varargs is the message to report. */
60 static void PRINTF_FORMAT (3, 0)
61 macro_error_valist (const struct macro_expansion_stack *stack,
62 const struct macro_token *mt, const char *format,
65 struct msg_stack **ms = NULL;
66 size_t allocated_ms = 0;
69 const struct macro_expansion_stack *p;
70 for (p = stack; p && p->next; p = p->next)
72 if (n_ms >= allocated_ms)
73 ms = x2nrealloc (ms, &allocated_ms, sizeof *ms);
75 /* TRANSLATORS: These strings are used for explaining the context of an
76 error. The "While expanding" message appears first, followed by zero
77 or more of the "inside expansion" messages. `innermost',
78 `next_inner`, etc., are names of macros, and `foobar' is a piece of
81 foo.sps:12: At `foobar' in the expansion of 'innermost',
82 foo.sps:23: inside the expansion of 'next_inner',
83 foo.sps:34: inside the expansion of 'next_inner2',
84 foo.sps:45: inside the expansion of 'outermost',
85 foo.sps:76: This is the actual error message. */
89 if (mt && mt->syntax.length)
92 str_ellipsize (mt->syntax, syntax, sizeof syntax);
93 description = xasprintf (_("At `%s' in the expansion of `%s',"),
97 description = xasprintf (_("In the expansion of `%s',"), p->name);
100 description = xasprintf (_("inside the expansion of `%s',"), p->name);
102 ms[n_ms] = xmalloc (sizeof *ms[n_ms]);
103 *ms[n_ms] = (struct msg_stack) {
104 .location = msg_location_dup (p->location),
105 .description = description,
110 struct msg *m = xmalloc (sizeof *m);
112 .category = MSG_C_SYNTAX,
113 .severity = MSG_S_ERROR,
116 .location = msg_location_dup (p ? p->location : NULL),
117 .text = xvasprintf (format, args),
122 /* Reports an error during macro expansion. STACK is the stack for reporting
123 the location of the error, MT is the optional token at which the error was
124 detected, and FORMAT along with the varargs is the message to report. */
125 static void PRINTF_FORMAT (3, 4)
126 macro_error (const struct macro_expansion_stack *stack,
127 const struct macro_token *mt, const char *format, ...)
130 va_start (args, format);
131 macro_error_valist (stack, mt, format, args);
136 macro_token_copy (struct macro_token *dst, const struct macro_token *src)
138 token_copy (&dst->token, &src->token);
139 ss_alloc_substring (&dst->syntax, src->syntax);
143 macro_token_uninit (struct macro_token *mt)
145 token_uninit (&mt->token);
146 ss_dealloc (&mt->syntax);
150 macro_token_to_syntax (struct macro_token *mt, struct string *s)
152 ds_put_substring (s, mt->syntax);
155 is_macro_keyword (struct substring s)
157 static struct stringi_set keywords = STRINGI_SET_INITIALIZER (keywords);
158 if (stringi_set_is_empty (&keywords))
160 static const char *kws[] = {
181 for (size_t i = 0; i < sizeof kws / sizeof *kws; i++)
182 stringi_set_insert (&keywords, kws[i]);
185 ss_ltrim (&s, ss_cstr ("!"));
186 return stringi_set_contains_len (&keywords, s.string, s.length);
190 macro_tokens_copy (struct macro_tokens *dst, const struct macro_tokens *src)
192 *dst = (struct macro_tokens) {
193 .mts = xmalloc (src->n * sizeof *dst->mts),
197 for (size_t i = 0; i < src->n; i++)
198 macro_token_copy (&dst->mts[i], &src->mts[i]);
202 macro_tokens_uninit (struct macro_tokens *mts)
204 for (size_t i = 0; i < mts->n; i++)
205 macro_token_uninit (&mts->mts[i]);
210 macro_tokens_add_uninit (struct macro_tokens *mts)
212 if (mts->n >= mts->allocated)
213 mts->mts = x2nrealloc (mts->mts, &mts->allocated, sizeof *mts->mts);
214 return &mts->mts[mts->n++];
218 macro_tokens_add (struct macro_tokens *mts, const struct macro_token *mt)
220 macro_token_copy (macro_tokens_add_uninit (mts), mt);
223 /* Tokenizes SRC according to MODE and appends the tokens to MTS. Uses STACK,
224 if nonull, for error reporting. */
226 macro_tokens_from_string__ (struct macro_tokens *mts, const struct substring src,
227 enum segmenter_mode mode,
228 const struct macro_expansion_stack *stack)
230 struct segmenter segmenter = segmenter_init (mode, true);
231 struct substring body = src;
233 while (body.length > 0)
235 struct macro_token mt = {
236 .token = { .type = T_STOP },
237 .syntax = { .string = body.string },
239 struct token *token = &mt.token;
241 enum segment_type type;
242 int seg_len = segmenter_push (&segmenter, body.string,
243 body.length, true, &type);
244 assert (seg_len >= 0);
246 struct substring segment = ss_head (body, seg_len);
247 enum tokenize_result result = token_from_segment (type, segment, token);
248 ss_advance (&body, seg_len);
256 mt.syntax.length = body.string - mt.syntax.string;
257 macro_tokens_add (mts, &mt);
261 mt.syntax.length = body.string - mt.syntax.string;
262 macro_error (stack, &mt, "%s", token->string.string);
266 token_uninit (token);
270 /* Tokenizes SRC according to MODE and appends the tokens to MTS. */
272 macro_tokens_from_string (struct macro_tokens *mts, const struct substring src,
273 enum segmenter_mode mode)
275 macro_tokens_from_string__ (mts, src, mode, NULL);
279 macro_tokens_print (const struct macro_tokens *mts, FILE *stream)
281 for (size_t i = 0; i < mts->n; i++)
282 token_print (&mts->mts[i].token, stream);
287 TC_ENDCMD, /* No space before or after (new-line after). */
288 TC_BINOP, /* Space on both sides. */
289 TC_COMMA, /* Space afterward. */
290 TC_ID, /* Don't need spaces except sequentially. */
291 TC_PUNCT, /* Don't need spaces except sequentially. */
295 needs_space (enum token_class prev, enum token_class next)
297 /* Don't need a space before or after the end of a command.
298 (A new-line is needed afterward as a special case.) */
299 if (prev == TC_ENDCMD || next == TC_ENDCMD)
302 /* Binary operators always have a space on both sides. */
303 if (prev == TC_BINOP || next == TC_BINOP)
306 /* A comma always has a space afterward. */
307 if (prev == TC_COMMA)
310 /* Otherwise, PREV is TC_ID or TC_PUNCT, which only need a space if there are
311 two or them in a row. */
315 static enum token_class
316 classify_token (enum token_type type)
368 /* Appends syntax for the tokens in MTS to S. If OFS and LEN are nonnull, sets
369 OFS[i] to the offset within S of the start of token 'i' in MTS and LEN[i] to
370 its length. OFS[i] + LEN[i] is not necessarily OFS[i + 1] because some
371 tokens are separated by white space. */
373 macro_tokens_to_syntax (struct macro_tokens *mts, struct string *s,
374 size_t *ofs, size_t *len)
376 assert ((ofs != NULL) == (len != NULL));
381 for (size_t i = 0; i < mts->n; i++)
385 enum token_type prev = mts->mts[i - 1].token.type;
386 enum token_type next = mts->mts[i].token.type;
388 if (prev == T_ENDCMD)
389 ds_put_byte (s, '\n');
392 enum token_class pc = classify_token (prev);
393 enum token_class nc = classify_token (next);
394 if (needs_space (pc, nc))
395 ds_put_byte (s, ' ');
400 ofs[i] = s->ss.length;
401 macro_token_to_syntax (&mts->mts[i], s);
403 len[i] = s->ss.length - ofs[i];
408 macro_destroy (struct macro *m)
414 msg_location_destroy (m->location);
415 for (size_t i = 0; i < m->n_params; i++)
417 struct macro_param *p = &m->params[i];
420 macro_tokens_uninit (&p->def);
421 token_uninit (&p->start);
422 token_uninit (&p->end);
425 macro_tokens_uninit (&m->body);
430 macro_set_create (void)
432 struct macro_set *set = xmalloc (sizeof *set);
433 *set = (struct macro_set) {
434 .macros = HMAP_INITIALIZER (set->macros),
440 macro_set_destroy (struct macro_set *set)
445 struct macro *macro, *next;
446 HMAP_FOR_EACH_SAFE (macro, next, struct macro, hmap_node, &set->macros)
448 hmap_delete (&set->macros, ¯o->hmap_node);
449 macro_destroy (macro);
451 hmap_destroy (&set->macros);
456 hash_macro_name (const char *name)
458 return utf8_hash_case_string (name, 0);
461 static struct macro *
462 macro_set_find__ (struct macro_set *set, const char *name)
464 if (macro_set_is_empty (set))
468 HMAP_FOR_EACH_WITH_HASH (macro, struct macro, hmap_node,
469 hash_macro_name (name), &set->macros)
470 if (!utf8_strcasecmp (macro->name, name))
477 macro_set_find (const struct macro_set *set, const char *name)
479 return macro_set_find__ (CONST_CAST (struct macro_set *, set), name);
482 /* Adds M to SET. M replaces any existing macro with the same name. Takes
485 macro_set_add (struct macro_set *set, struct macro *m)
487 struct macro *victim = macro_set_find__ (set, m->name);
490 hmap_delete (&set->macros, &victim->hmap_node);
491 macro_destroy (victim);
494 hmap_insert (&set->macros, &m->hmap_node, hash_macro_name (m->name));
497 /* Macro call parsing. */
501 /* Accumulating tokens in mc->params toward the end of any type of
505 /* Expecting the opening delimiter of an ARG_ENCLOSE argument. */
508 /* Expecting a keyword for a keyword argument. */
511 /* Expecting an equal sign for a keyword argument. */
514 /* Macro fully parsed and ready for expansion. */
518 /* Parsing macro calls. This is a FSM driven by macro_call_create() and
519 macro_call_add() to identify the macro being called and obtain its
520 arguments. 'state' identifies the FSM state. */
523 const struct macro_set *macros;
524 const struct macro *macro;
525 struct macro_tokens **args;
526 const struct macro_expansion_stack *stack;
527 const struct macro_expander *me;
531 const struct macro_param *param; /* Parameter currently being parsed. */
534 static bool macro_expand_arg (const struct token *,
535 const struct macro_expander *,
536 struct macro_tokens *exp);
538 /* Completes macro expansion by initializing arguments that weren't supplied to
541 mc_finished (struct macro_call *mc)
543 mc->state = MC_FINISHED;
544 for (size_t i = 0; i < mc->macro->n_params; i++)
546 mc->args[i] = &mc->macro->params[i].def;
551 mc_next_arg (struct macro_call *mc)
555 assert (!mc->macro->n_params);
556 return mc_finished (mc);
558 else if (mc->param->positional)
561 if (mc->param >= &mc->macro->params[mc->macro->n_params])
562 return mc_finished (mc);
565 mc->state = (!mc->param->positional ? MC_KEYWORD
566 : mc->param->arg_type == ARG_ENCLOSE ? MC_ENCLOSE
573 for (size_t i = 0; i < mc->macro->n_params; i++)
576 mc->state = MC_KEYWORD;
579 return mc_finished (mc);
583 static void PRINTF_FORMAT (3, 4)
584 mc_error (const struct macro_call *mc, const struct msg_location *loc,
585 const char *format, ...)
588 va_start (args, format);
591 const struct macro_expansion_stack stack = { .location = loc };
592 macro_error_valist (&stack, NULL, format, args);
595 macro_error_valist (mc->stack, NULL, format, args);
600 mc_add_arg (struct macro_call *mc, const struct macro_token *mt,
601 const struct msg_location *loc)
603 const struct macro_param *p = mc->param;
604 struct macro_tokens **argp = &mc->args[p - mc->macro->params];
606 const struct token *token = &mt->token;
607 if (token->type == T_ENDCMD || token->type == T_STOP)
614 /* This is OK, it's the expected way to end the argument. */
619 ngettext (_("Reached end of command expecting %zu "
620 "more token in argument %s to macro %s."),
621 _("Reached end of command expecting %zu "
622 "more tokens in argument %s to macro %s."),
623 p->n_tokens - (*argp)->n),
624 p->n_tokens - (*argp)->n, p->name, mc->macro->name);
630 char *end = token_to_string (&p->end);
631 mc_error (mc, loc, _("Reached end of command expecting \"%s\" "
632 "in argument %s to macro %s."),
633 end, p->name, mc->macro->name);
640 /* The end of a command ends the current argument, precludes any further
641 arguments, and is not itself part of the argument. */
642 return mc_finished (mc);
648 *argp = xzalloc (sizeof **argp);
650 bool add_token; /* Should we add 'mt' to the current arg? */
651 bool next_arg; /* Should we advance to the next arg? */
655 next_arg = (*argp)->n + 1 >= p->n_tokens;
661 next_arg = token_equal (token, &p->end);
662 add_token = !next_arg;
676 if (!macro_expand_arg (&mt->token, mc->me, *argp))
677 macro_tokens_add (*argp, mt);
679 return next_arg ? mc_next_arg (mc) : 0;
683 mc_expected (struct macro_call *mc, const struct macro_token *actual,
684 const struct msg_location *loc, const struct token *expected)
686 const struct substring actual_s = (actual->syntax.length ? actual->syntax
687 : ss_cstr (_("<end of input>")));
688 char *expected_s = token_to_string (expected);
690 _("Found `%.*s' while expecting `%s' reading argument %s "
692 (int) actual_s.length, actual_s.string, expected_s,
693 mc->param->name, mc->macro->name);
696 return mc_finished (mc);
700 mc_enclose (struct macro_call *mc, const struct macro_token *mt,
701 const struct msg_location *loc)
703 const struct token *token = &mt->token;
704 const struct macro_param *p = mc->param;
705 if (token_equal (&p->start, token))
709 struct macro_tokens **argp = &mc->args[p - mc->macro->params];
710 *argp = xzalloc (sizeof **argp);
714 else if (p->positional && (token->type == T_ENDCMD || token->type == T_STOP))
715 return mc_finished (mc);
717 return mc_expected (mc, mt, loc, &p->start);
720 static const struct macro_param *
721 macro_find_parameter_by_name (const struct macro *m, struct substring name)
726 ss_ltrim (&name, ss_cstr ("!"));
728 for (size_t i = 0; i < m->n_params; i++)
730 const struct macro_param *p = &m->params[i];
731 struct substring p_name = ss_cstr (p->name + 1);
732 if (!utf8_strncasecmp (p_name.string, p_name.length,
733 name.string, name.length))
740 mc_keyword (struct macro_call *mc, const struct macro_token *mt,
741 const struct msg_location *loc)
743 const struct token *token = &mt->token;
744 if (token->type != T_ID)
745 return mc_finished (mc);
747 const struct macro_param *p = macro_find_parameter_by_name (mc->macro,
751 struct macro_tokens **argp = &mc->args[p - mc->macro->params];
754 _("Argument %s multiply specified in call to macro %s."),
755 p->name, mc->macro->name);
757 *argp = xzalloc (sizeof **argp);
760 mc->state = MC_EQUALS;
764 return mc_finished (mc);
768 mc_equals (struct macro_call *mc, const struct macro_token *mt,
769 const struct msg_location *loc)
771 if (mt->token.type == T_EQUALS)
774 mc->state = mc->param->arg_type == ARG_ENCLOSE ? MC_ENCLOSE : MC_ARG;
778 return mc_expected (mc, mt, loc, &(struct token) { .type = T_EQUALS });
782 macro_call_create__ (const struct macro_set *macros,
783 const struct macro_expansion_stack *stack,
784 const struct macro_expander *me,
785 const struct token *token,
786 struct macro_call **mcp)
788 const struct macro *macro = (token->type == T_ID || token->type == T_MACRO_ID
789 ? macro_set_find (macros, token->string.string)
797 struct macro_call *mc = xmalloc (sizeof *mc);
798 *mc = (struct macro_call) {
802 .state = (!macro->n_params ? MC_FINISHED
803 : !macro->params[0].positional ? MC_KEYWORD
804 : macro->params[0].arg_type == ARG_ENCLOSE ? MC_ENCLOSE
806 .args = macro->n_params ? xcalloc (macro->n_params, sizeof *mc->args) : NULL,
807 .param = macro->params,
813 return mc->state == MC_FINISHED ? 1 : 0;
816 /* If TOKEN is the first token of a call to a macro in MACROS, create a new
817 macro expander, initializes *MCP to it. Returns 0 if more tokens are needed
818 and should be added via macro_call_add() or 1 if the caller should next call
819 macro_call_get_expansion().
821 If TOKEN is not the first token of a macro call, returns -1 and sets *MCP to
824 macro_call_create (const struct macro_set *macros,
825 const struct token *token,
826 struct macro_call **mcp)
828 return macro_call_create__ (macros, NULL, NULL, token, mcp);
832 macro_call_destroy (struct macro_call *mc)
837 for (size_t i = 0; i < mc->macro->n_params; i++)
839 struct macro_tokens *a = mc->args[i];
840 if (a && a != &mc->macro->params[i].def)
842 macro_tokens_uninit (a);
850 /* Adds TOKEN to the collection of tokens in MC that potentially need to be
853 Returns -1 if the tokens added do not actually invoke a macro. The caller
854 should consume the first token without expanding it. (Later tokens might
855 invoke a macro so it's best to feed the second token into a new expander.)
857 Returns 0 if the macro expander needs more tokens, for macro arguments or to
858 decide whether this is actually a macro invocation. The caller should call
859 macro_call_add() again with the next token.
861 Returns a positive number to indicate that the returned number of tokens
862 invoke a macro. The number returned might be less than the number of tokens
863 added because it can take a few tokens of lookahead to determine whether the
864 macro invocation is finished. The caller should call
865 macro_call_get_expansion() to obtain the expansion. */
867 macro_call_add (struct macro_call *mc, const struct macro_token *mt,
868 const struct msg_location *loc)
873 return mc_add_arg (mc, mt, loc);
876 return mc_enclose (mc, mt, loc);
879 return mc_keyword (mc, mt, loc);
882 return mc_equals (mc, mt, loc);
889 /* Macro expansion. */
891 struct macro_expander
893 /* Always available. */
894 const struct macro_set *macros; /* Macros to expand recursively. */
895 enum segmenter_mode segmenter_mode; /* Mode for tokenization. */
896 int nesting_countdown; /* Remaining nesting levels. */
897 const struct macro_expansion_stack *stack; /* Stack for error reporting. */
898 bool *expand; /* May macro calls be expanded? */
899 struct stringi_map *vars; /* Variables from !do and !let. */
901 /* Only nonnull if inside a !DO loop. */
902 bool *break_; /* Set to true to break out of loop. */
904 /* Only nonnull if expanding a macro (and not, say, a macro argument). */
905 const struct macro *macro;
906 struct macro_tokens **args;
910 macro_expand (const struct macro_token *mts, size_t n_mts,
911 const struct macro_expander *, struct macro_tokens *);
914 expand_macro_function (const struct macro_expander *me,
915 const struct macro_token *input, size_t n_input,
916 struct string *output);
918 /* Parses one function argument from the N_INPUT tokens in INPUT
919 Each argument to a macro function is one of:
921 - A quoted string or other single literal token.
923 - An argument to the macro being expanded, e.g. !1 or a named argument.
927 - A function invocation.
929 Each function invocation yields a character sequence to be turned into a
930 sequence of tokens. The case where that character sequence is a single
931 quoted string is an important special case.
934 parse_function_arg (const struct macro_expander *me,
935 const struct macro_token *input, size_t n_input,
938 assert (n_input > 0);
940 const struct token *token = &input[0].token;
941 if (token->type == T_MACRO_ID && me->macro)
943 const struct macro_param *param = macro_find_parameter_by_name (
944 me->macro, token->string);
947 size_t param_idx = param - me->macro->params;
948 macro_tokens_to_syntax (me->args[param_idx], farg, NULL, NULL);
952 if (ss_equals (token->string, ss_cstr ("!*")))
954 for (size_t i = 0; i < me->macro->n_params; i++)
956 if (!me->macro->params[i].positional)
959 ds_put_byte (farg, ' ');
960 macro_tokens_to_syntax (me->args[i], farg, NULL, NULL);
965 const char *var = stringi_map_find__ (me->vars,
966 token->string.string,
967 token->string.length);
970 ds_put_cstr (farg, var);
974 size_t n_function = expand_macro_function (me, input, n_input, farg);
979 ds_put_substring (farg, input[0].syntax);
984 parse_function_args (const struct macro_expander *me,
985 const struct macro_token *mts, size_t n,
986 const char *function,
987 struct string_array *args)
989 assert (n >= 2 && mts[1].token.type == T_LPAREN);
991 for (size_t i = 2; i < n; )
993 if (mts[i].token.type == T_RPAREN)
996 struct string s = DS_EMPTY_INITIALIZER;
997 i += parse_function_arg (me, mts + i, n - i, &s);
998 string_array_append_nocopy (args, ds_steal_cstr (&s));
1002 else if (mts[i].token.type == T_COMMA)
1004 else if (mts[i].token.type != T_RPAREN)
1006 macro_error (me->stack, &mts[i],
1007 _("`,' or `)' expected in call to macro function %s."),
1013 macro_error (me->stack, NULL, _("Missing `)' in call to macro function %s."),
1019 unquote_string (const char *s, enum segmenter_mode segmenter_mode,
1020 struct string *content)
1022 struct string_lexer slex;
1023 string_lexer_init (&slex, s, strlen (s), segmenter_mode, true);
1025 struct token token1;
1026 if (string_lexer_next (&slex, &token1) != SLR_TOKEN
1027 || token1.type != T_STRING)
1029 token_uninit (&token1);
1033 struct token token2;
1034 if (string_lexer_next (&slex, &token2) != SLR_END)
1036 token_uninit (&token1);
1037 token_uninit (&token2);
1041 ds_put_substring (content, token1.string);
1042 token_uninit (&token1);
1047 unquote_string_in_place (const char *s, enum segmenter_mode segmenter_mode,
1050 ds_init_empty (tmp);
1051 return unquote_string (s, segmenter_mode, tmp) ? ds_cstr (tmp) : s;
1055 parse_integer (const char *s, int *np)
1060 long int n = strtol (s, &tail, 10);
1061 *np = n < INT_MIN ? INT_MIN : n > INT_MAX ? INT_MAX : n;
1062 tail += strspn (tail, CC_SPACES);
1063 return *tail == '\0' && errno != ERANGE && n == *np;
1067 expand_macro_function (const struct macro_expander *me,
1068 const struct macro_token *input, size_t n_input,
1069 struct string *output)
1071 if (!n_input || input[0].token.type != T_MACRO_ID)
1074 struct macro_function
1080 enum macro_function_id
1094 static const struct macro_function mfs[] = {
1095 [MF_BLANKS] = { "!BLANKS", 1, 1 },
1096 [MF_CONCAT] = { "!CONCAT", 1, INT_MAX },
1097 [MF_EVAL] = { "!EVAL", 1, 1 },
1098 [MF_HEAD] = { "!HEAD", 1, 1 },
1099 [MF_INDEX] = { "!INDEX", 2, 2 },
1100 [MF_LENGTH] = { "!LENGTH", 1, 1 },
1101 [MF_QUOTE] = { "!QUOTE", 1, 1 },
1102 [MF_SUBSTR] = { "!SUBSTR", 2, 3 },
1103 [MF_TAIL] = { "!TAIL", 1, 1 },
1104 [MF_UNQUOTE] = { "!UNQUOTE", 1, 1 },
1105 [MF_UPCASE] = { "!UPCASE", 1, 1 },
1108 if (lex_id_match_n (ss_cstr ("!NULL"), input[0].token.string, 4))
1111 if (n_input < 2 || input[1].token.type != T_LPAREN)
1113 /* Only consider macro functions when the name is followed by '('. */
1117 /* Is this a macro function name? */
1118 const struct macro_function *mf;
1119 for (mf = mfs; ; mf++)
1121 if (mf >= mfs + sizeof mfs / sizeof *mfs)
1123 /* Not a macro function. */
1127 if (lex_id_match_n (ss_cstr (mf->name), input[0].token.string, 4))
1131 enum macro_function_id id = mf - mfs;
1133 struct string_array args = STRING_ARRAY_INITIALIZER;
1134 size_t n_consumed = parse_function_args (me, input, n_input, mf->name, &args);
1138 if (args.n < mf->min_args || args.n > mf->max_args)
1140 if (mf->min_args == 1 && mf->max_args == 1)
1141 macro_error (me->stack, NULL,
1142 _("Macro function %s takes one argument (not %zu)."),
1144 else if (mf->min_args == 2 && mf->max_args == 2)
1145 macro_error (me->stack, NULL,
1146 _("Macro function %s takes two arguments (not %zu)."),
1148 else if (mf->min_args == 2 && mf->max_args == 3)
1149 macro_error (me->stack, NULL,
1150 _("Macro function %s takes two or three arguments "
1153 else if (mf->min_args == 1 && mf->max_args == INT_MAX)
1154 macro_error (me->stack, NULL,
1155 _("Macro function %s needs at least one argument."),
1165 ds_put_format (output, "%zu", strlen (args.strings[0]));
1171 if (!parse_integer (args.strings[0], &n))
1173 macro_error (me->stack, NULL,
1174 _("Argument to !BLANKS must be non-negative integer "
1175 "(not \"%s\")."), args.strings[0]);
1176 string_array_destroy (&args);
1180 ds_put_byte_multiple (output, ' ', n);
1185 for (size_t i = 0; i < args.n; i++)
1186 if (!unquote_string (args.strings[i], me->segmenter_mode, output))
1187 ds_put_cstr (output, args.strings[i]);
1193 const char *s = unquote_string_in_place (args.strings[0],
1194 me->segmenter_mode, &tmp);
1196 struct macro_tokens mts = { .n = 0 };
1197 macro_tokens_from_string__ (&mts, ss_cstr (s), me->segmenter_mode,
1200 ds_put_substring (output, mts.mts[0].syntax);
1201 macro_tokens_uninit (&mts);
1208 const char *haystack = args.strings[0];
1209 const char *needle = strstr (haystack, args.strings[1]);
1210 ds_put_format (output, "%zu", needle ? needle - haystack + 1 : 0);
1215 if (unquote_string (args.strings[0], me->segmenter_mode, NULL))
1216 ds_put_cstr (output, args.strings[0]);
1219 ds_extend (output, strlen (args.strings[0]) + 2);
1220 ds_put_byte (output, '\'');
1221 for (const char *p = args.strings[0]; *p; p++)
1224 ds_put_byte (output, '\'');
1225 ds_put_byte (output, *p);
1227 ds_put_byte (output, '\'');
1234 if (!parse_integer (args.strings[1], &start) || start < 1)
1236 macro_error (me->stack, NULL,
1237 _("Second argument of !SUBSTR must be "
1238 "positive integer (not \"%s\")."),
1240 string_array_destroy (&args);
1244 int count = INT_MAX;
1245 if (args.n > 2 && (!parse_integer (args.strings[2], &count) || count < 0))
1247 macro_error (me->stack, NULL,
1248 _("Third argument of !SUBSTR must be "
1249 "non-negative integer (not \"%s\")."),
1251 string_array_destroy (&args);
1255 struct substring s = ss_cstr (args.strings[0]);
1256 ds_put_substring (output, ss_substr (s, start - 1, count));
1263 const char *s = unquote_string_in_place (args.strings[0],
1264 me->segmenter_mode, &tmp);
1266 struct macro_tokens mts = { .n = 0 };
1267 macro_tokens_from_string__ (&mts, ss_cstr (s), me->segmenter_mode,
1271 struct macro_tokens tail = { .mts = mts.mts + 1, .n = mts.n - 1 };
1272 macro_tokens_to_syntax (&tail, output, NULL, NULL);
1274 macro_tokens_uninit (&mts);
1280 if (!unquote_string (args.strings[0], me->segmenter_mode, output))
1281 ds_put_cstr (output, args.strings[0]);
1287 const char *s = unquote_string_in_place (args.strings[0],
1288 me->segmenter_mode, &tmp);
1289 char *upper = utf8_to_upper (s);
1290 ds_put_cstr (output, upper);
1298 struct macro_tokens mts = { .n = 0 };
1299 macro_tokens_from_string__ (&mts, ss_cstr (args.strings[0]),
1300 me->segmenter_mode, me->stack);
1301 struct macro_tokens exp = { .n = 0 };
1302 struct macro_expansion_stack stack = {
1306 struct macro_expander subme = *me;
1307 subme.break_ = NULL;
1308 subme.stack = &stack;
1310 macro_expand (mts.mts, mts.n, &subme, &exp);
1311 macro_tokens_to_syntax (&exp, output, NULL, NULL);
1312 macro_tokens_uninit (&exp);
1313 macro_tokens_uninit (&mts);
1321 string_array_destroy (&args);
1325 static char *macro_evaluate_or (const struct macro_expander *me,
1326 const struct macro_token **tokens,
1327 const struct macro_token *end);
1330 macro_evaluate_literal (const struct macro_expander *me,
1331 const struct macro_token **tokens,
1332 const struct macro_token *end)
1334 const struct macro_token *p = *tokens;
1337 if (p->token.type == T_LPAREN)
1340 char *value = macro_evaluate_or (me, &p, end);
1343 if (p >= end || p->token.type != T_RPAREN)
1346 macro_error (me->stack, p < end ? p : NULL,
1347 _("Expecting ')' in macro expression."));
1354 else if (p->token.type == T_RPAREN)
1356 macro_error (me->stack, p, _("Expecting literal or function invocation "
1357 "in macro expression."));
1361 struct string function_output = DS_EMPTY_INITIALIZER;
1362 size_t function_consumed = parse_function_arg (me, p, end - p,
1364 struct string unquoted = DS_EMPTY_INITIALIZER;
1365 if (unquote_string (ds_cstr (&function_output), me->segmenter_mode,
1368 ds_swap (&function_output, &unquoted);
1369 ds_destroy (&unquoted);
1371 *tokens = p + function_consumed;
1372 return ds_steal_cstr (&function_output);
1375 /* Returns true if MT is valid as a macro operator. Only operators written as
1376 symbols (e.g. <>) are usable in macro expressions, not operator written as
1377 letters (e.g. EQ). */
1379 is_macro_operator (const struct macro_token *mt)
1381 return mt->syntax.length > 0 && !c_isalpha (mt->syntax.string[0]);
1384 static enum token_type
1385 parse_relational_op (const struct macro_token *mt)
1387 switch (mt->token.type)
1397 return is_macro_operator (mt) ? mt->token.type : T_STOP;
1400 return (ss_equals_case (mt->token.string, ss_cstr ("!EQ")) ? T_EQ
1401 : ss_equals_case (mt->token.string, ss_cstr ("!NE")) ? T_NE
1402 : ss_equals_case (mt->token.string, ss_cstr ("!LT")) ? T_LT
1403 : ss_equals_case (mt->token.string, ss_cstr ("!GT")) ? T_GT
1404 : ss_equals_case (mt->token.string, ss_cstr ("!LE")) ? T_LE
1405 : ss_equals_case (mt->token.string, ss_cstr ("!GE")) ? T_GE
1414 macro_evaluate_relational (const struct macro_expander *me,
1415 const struct macro_token **tokens,
1416 const struct macro_token *end)
1418 const struct macro_token *p = *tokens;
1419 char *lhs = macro_evaluate_literal (me, &p, end);
1423 enum token_type op = p >= end ? T_STOP : parse_relational_op (p);
1431 char *rhs = macro_evaluate_literal (me, &p, end);
1438 struct string lhs_tmp, rhs_tmp;
1439 int cmp = strcmp (unquote_string_in_place (lhs, me->segmenter_mode,
1441 unquote_string_in_place (rhs, me->segmenter_mode,
1443 ds_destroy (&lhs_tmp);
1444 ds_destroy (&rhs_tmp);
1449 bool b = (op == T_EQUALS || op == T_EQ ? !cmp
1451 : op == T_LT ? cmp < 0
1452 : op == T_GT ? cmp > 0
1453 : op == T_LE ? cmp <= 0
1454 : /* T_GE */ cmp >= 0);
1457 return xstrdup (b ? "1" : "0");
1461 macro_evaluate_not (const struct macro_expander *me,
1462 const struct macro_token **tokens,
1463 const struct macro_token *end)
1465 const struct macro_token *p = *tokens;
1467 unsigned int negations = 0;
1469 && (ss_equals_case (p->syntax, ss_cstr ("!NOT"))
1470 || ss_equals (p->syntax, ss_cstr ("~"))))
1476 char *operand = macro_evaluate_relational (me, &p, end);
1477 if (!operand || !negations)
1483 bool b = strcmp (operand, "0") ^ (negations & 1);
1486 return xstrdup (b ? "1" : "0");
1490 macro_evaluate_and (const struct macro_expander *me,
1491 const struct macro_token **tokens,
1492 const struct macro_token *end)
1494 const struct macro_token *p = *tokens;
1495 char *lhs = macro_evaluate_not (me, &p, end);
1500 && (ss_equals_case (p->syntax, ss_cstr ("!AND"))
1501 || ss_equals (p->syntax, ss_cstr ("&"))))
1504 char *rhs = macro_evaluate_not (me, &p, end);
1511 bool b = strcmp (lhs, "0") && strcmp (rhs, "0");
1514 lhs = xstrdup (b ? "1" : "0");
1521 macro_evaluate_or (const struct macro_expander *me,
1522 const struct macro_token **tokens,
1523 const struct macro_token *end)
1525 const struct macro_token *p = *tokens;
1526 char *lhs = macro_evaluate_and (me, &p, end);
1531 && (ss_equals_case (p->syntax, ss_cstr ("!OR"))
1532 || ss_equals (p->syntax, ss_cstr ("|"))))
1535 char *rhs = macro_evaluate_and (me, &p, end);
1542 bool b = strcmp (lhs, "0") || strcmp (rhs, "0");
1545 lhs = xstrdup (b ? "1" : "0");
1552 macro_evaluate_expression (const struct macro_token **tokens, size_t n_tokens,
1553 const struct macro_expander *me)
1555 return macro_evaluate_or (me, tokens, *tokens + n_tokens);
1559 macro_evaluate_number (const struct macro_token **tokens, size_t n_tokens,
1560 const struct macro_expander *me,
1563 char *s = macro_evaluate_expression (tokens, n_tokens, me);
1567 struct macro_tokens mts = { .n = 0 };
1568 macro_tokens_from_string__ (&mts, ss_cstr (s), me->segmenter_mode, me->stack);
1569 if (mts.n != 1 || !token_is_number (&mts.mts[0].token))
1571 macro_error (me->stack, mts.n > 0 ? &mts.mts[0] : NULL,
1572 _("Macro expression must evaluate to "
1573 "a number (not \"%s\")."), s);
1575 macro_tokens_uninit (&mts);
1579 *number = token_number (&mts.mts[0].token);
1581 macro_tokens_uninit (&mts);
1585 static const struct macro_token *
1586 find_ifend_clause (const struct macro_token *p, const struct macro_token *end)
1589 for (; p < end; p++)
1591 if (p->token.type != T_MACRO_ID)
1594 if (ss_equals_case (p->token.string, ss_cstr ("!IF")))
1596 else if (lex_id_match_n (p->token.string, ss_cstr ("!IFEND"), 4))
1602 else if (lex_id_match_n (p->token.string, ss_cstr ("!ELSE"), 4)
1610 macro_expand_if (const struct macro_token *tokens, size_t n_tokens,
1611 const struct macro_expander *me,
1612 struct macro_tokens *exp)
1614 const struct macro_token *p = tokens;
1615 const struct macro_token *end = tokens + n_tokens;
1617 if (p >= end || !ss_equals_case (p->token.string, ss_cstr ("!IF")))
1621 char *result = macro_evaluate_expression (&p, end - p, me);
1624 bool b = strcmp (result, "0");
1628 || p->token.type != T_MACRO_ID
1629 || !lex_id_match_n (p->token.string, ss_cstr ("!THEN"), 4))
1631 macro_error (me->stack, p < end ? p : NULL,
1632 _("!THEN expected in macro !IF construct."));
1636 const struct macro_token *start_then = p + 1;
1637 const struct macro_token *end_then = find_ifend_clause (start_then, end);
1640 macro_error (me->stack, NULL,
1641 _("!ELSE or !IFEND expected in macro !IF construct."));
1645 const struct macro_token *start_else, *end_if;
1646 if (lex_id_match_n (end_then->token.string, ss_cstr ("!ELSE"), 4))
1648 start_else = end_then + 1;
1649 end_if = find_ifend_clause (start_else, end);
1651 || !lex_id_match_n (end_if->token.string, ss_cstr ("!IFEND"), 4))
1653 macro_error (me->stack, end_if ? end_if : NULL,
1654 _("!IFEND expected in macro !IF construct."));
1664 const struct macro_token *start;
1669 n = end_then - start_then;
1671 else if (start_else)
1674 n = end_if - start_else;
1684 struct macro_expansion_stack stack = {
1688 struct macro_expander subme = *me;
1689 subme.stack = &stack;
1690 macro_expand (start, n, &subme, exp);
1692 return (end_if + 1) - tokens;
1696 macro_parse_let (const struct macro_token *tokens, size_t n_tokens,
1697 const struct macro_expander *me)
1699 const struct macro_token *p = tokens;
1700 const struct macro_token *end = tokens + n_tokens;
1702 if (p >= end || !ss_equals_case (p->token.string, ss_cstr ("!LET")))
1706 if (p >= end || p->token.type != T_MACRO_ID)
1708 macro_error (me->stack, p < end ? p : NULL,
1709 _("Expected macro variable name following !LET."));
1712 const struct substring var_name = p->token.string;
1713 if (is_macro_keyword (var_name)
1714 || macro_find_parameter_by_name (me->macro, var_name))
1716 macro_error (me->stack, p < end ? p : NULL,
1717 _("Cannot use argument name or macro keyword "
1718 "\"%.*s\" as !LET variable."),
1719 (int) var_name.length, var_name.string);
1724 if (p >= end || p->token.type != T_EQUALS)
1726 macro_error (me->stack, p < end ? p : NULL,
1727 _("Expected `=' following !LET."));
1732 char *value = macro_evaluate_expression (&p, end - p, me);
1736 stringi_map_replace_nocopy (me->vars, ss_xstrdup (var_name), value);
1740 static const struct macro_token *
1741 find_doend (const struct macro_expansion_stack *stack,
1742 const struct macro_token *p, const struct macro_token *end)
1745 for (; p < end; p++)
1747 if (p->token.type != T_MACRO_ID)
1750 if (ss_equals_case (p->token.string, ss_cstr ("!DO")))
1752 else if (lex_id_match_n (p->token.string, ss_cstr ("!DOEND"), 4))
1759 macro_error (stack, NULL, _("Missing !DOEND."));
1764 macro_expand_do (const struct macro_token *tokens, size_t n_tokens,
1765 const struct macro_expander *me,
1766 struct macro_tokens *exp)
1768 const struct macro_token *p = tokens;
1769 const struct macro_token *end = tokens + n_tokens;
1771 if (p >= end || !ss_equals_case (p->token.string, ss_cstr ("!DO")))
1775 if (p >= end || p->token.type != T_MACRO_ID)
1777 macro_error (me->stack, p < end ? p : NULL,
1778 _("Expected macro variable name following !DO."));
1781 const struct substring var_name = p->token.string;
1782 if (is_macro_keyword (var_name)
1783 || macro_find_parameter_by_name (me->macro, var_name))
1785 macro_error (me->stack, p, _("Cannot use argument name or macro "
1786 "keyword as !DO variable."));
1791 struct macro_expansion_stack substack = {
1795 bool break_ = false;
1796 struct macro_expander subme = *me;
1797 subme.break_ = &break_;
1798 subme.stack = &substack;
1800 int miterate = settings_get_miterate ();
1801 if (p < end && p->token.type == T_MACRO_ID
1802 && ss_equals_case (p->token.string, ss_cstr ("!IN")))
1805 char *list = macro_evaluate_expression (&p, end - p, &subme);
1809 struct macro_tokens items = { .n = 0 };
1810 macro_tokens_from_string__ (&items, ss_cstr (list), me->segmenter_mode,
1814 const struct macro_token *do_end = find_doend (subme.stack, p, end);
1817 macro_tokens_uninit (&items);
1821 for (size_t i = 0; i < items.n && !break_; i++)
1825 macro_error (&substack, NULL,
1826 _("!DO loop over list exceeded "
1827 "maximum number of iterations %d. "
1828 "(Use SET MITERATE to change the limit.)"),
1832 stringi_map_replace_nocopy (me->vars, ss_xstrdup (var_name),
1833 ss_xstrdup (items.mts[i].syntax));
1835 macro_expand (p, do_end - p, &subme, exp);
1837 return do_end - tokens + 1;
1839 else if (p < end && p->token.type == T_EQUALS)
1843 if (!macro_evaluate_number (&p, end - p, &subme, &first))
1846 if (p >= end || p->token.type != T_MACRO_ID
1847 || !ss_equals_case (p->token.string, ss_cstr ("!TO")))
1849 macro_error (subme.stack, p < end ? p : NULL,
1850 _("Expected !TO in numerical !DO loop."));
1856 if (!macro_evaluate_number (&p, end - p, &subme, &last))
1860 if (p < end && p->token.type == T_MACRO_ID
1861 && ss_equals_case (p->token.string, ss_cstr ("!BY")))
1864 if (!macro_evaluate_number (&p, end - p, &subme, &by))
1869 macro_error (subme.stack, NULL, _("!BY value cannot be zero."));
1874 const struct macro_token *do_end = find_doend (subme.stack, p, end);
1877 if ((by > 0 && first <= last) || (by < 0 && first >= last))
1880 for (double index = first;
1881 by > 0 ? (index <= last) : (index >= last) && !break_;
1886 macro_error (subme.stack, NULL,
1887 _("Numerical !DO loop exceeded "
1888 "maximum number of iterations %d. "
1889 "(Use SET MITERATE to change the limit.)"),
1894 char index_s[DBL_BUFSIZE_BOUND];
1895 c_dtoastr (index_s, sizeof index_s, 0, 0, index);
1896 stringi_map_replace_nocopy (me->vars, ss_xstrdup (var_name),
1899 macro_expand (p, do_end - p, &subme, exp);
1903 return do_end - tokens + 1;
1907 macro_error (me->stack, p < end ? p : NULL,
1908 _("Expected `=' or !IN in !DO loop."));
1914 macro_expand_arg__ (const struct macro_expander *me, size_t idx,
1915 struct macro_tokens *exp)
1917 const struct macro_param *param = &me->macro->params[idx];
1918 const struct macro_tokens *arg = me->args[idx];
1920 if (*me->expand && param->expand_arg)
1922 struct stringi_map vars = STRINGI_MAP_INITIALIZER (vars);
1923 struct macro_expansion_stack stack = {
1924 .name = param->name,
1927 struct macro_expander subme = {
1928 .macros = me->macros,
1931 .segmenter_mode = me->segmenter_mode,
1932 .expand = me->expand,
1935 .nesting_countdown = me->nesting_countdown,
1938 macro_expand (arg->mts, arg->n, &subme, exp);
1939 stringi_map_destroy (&vars);
1942 for (size_t i = 0; i < arg->n; i++)
1943 macro_tokens_add (exp, &arg->mts[i]);
1947 macro_expand_arg (const struct token *token, const struct macro_expander *me,
1948 struct macro_tokens *exp)
1950 if (!me || token->type != T_MACRO_ID)
1953 /* Macro arguments. */
1956 const struct macro_param *param = macro_find_parameter_by_name (
1957 me->macro, token->string);
1960 macro_expand_arg__ (me, param - me->macro->params, exp);
1963 else if (ss_equals (token->string, ss_cstr ("!*")))
1965 for (size_t j = 0; j < me->macro->n_params; j++)
1966 macro_expand_arg__ (me, j, exp);
1971 /* Variables set by !DO or !LET. */
1972 const char *var = stringi_map_find__ (me->vars, token->string.string,
1973 token->string.length);
1976 macro_tokens_from_string__ (exp, ss_cstr (var),
1977 me->segmenter_mode, me->stack);
1985 macro_expand__ (const struct macro_token *mts, size_t n,
1986 const struct macro_expander *me,
1987 struct macro_tokens *exp)
1989 const struct token *token = &mts[0].token;
1991 /* Recursive macro calls. */
1994 struct macro_call *submc;
1995 int n_call = macro_call_create__ (me->macros, me->stack, me,
1997 for (size_t j = 1; !n_call; j++)
1999 const struct macro_token endcmd
2000 = { .token = { .type = T_ENDCMD } };
2001 n_call = macro_call_add (submc, j < n ? &mts[j] : &endcmd, NULL);
2005 struct stringi_map vars = STRINGI_MAP_INITIALIZER (vars);
2006 struct macro_expansion_stack stack = {
2007 .name = submc->macro->name,
2008 .location = submc->macro->location,
2011 struct macro_expander subme = {
2012 .macros = submc->macros,
2013 .macro = submc->macro,
2014 .args = submc->args,
2015 .segmenter_mode = me->segmenter_mode,
2016 .expand = me->expand,
2019 .nesting_countdown = me->nesting_countdown - 1,
2022 const struct macro_tokens *body = &submc->macro->body;
2023 macro_expand (body->mts, body->n, &subme, exp);
2024 macro_call_destroy (submc);
2025 stringi_map_destroy (&vars);
2029 macro_call_destroy (submc);
2032 if (token->type != T_MACRO_ID)
2034 macro_tokens_add (exp, &mts[0]);
2038 /* Parameters and macro variables. */
2039 if (macro_expand_arg (token, me, exp))
2042 /* Macro functions. */
2043 struct string function_output = DS_EMPTY_INITIALIZER;
2044 size_t n_function = expand_macro_function (me, mts, n, &function_output);
2047 macro_tokens_from_string__ (exp, function_output.ss,
2048 me->segmenter_mode, me->stack);
2049 ds_destroy (&function_output);
2054 size_t n_if = macro_expand_if (mts, n, me, exp);
2058 size_t n_let = macro_parse_let (mts, n, me);
2062 size_t n_do = macro_expand_do (mts, n, me, exp);
2066 if (lex_id_match_n (token->string, ss_cstr ("!break"), 4))
2071 macro_error (me->stack, &mts[0], _("!BREAK outside !DO."));
2073 else if (lex_id_match_n (token->string, ss_cstr ("!onexpand"), 4))
2075 else if (lex_id_match_n (token->string, ss_cstr ("!offexpand"), 4))
2076 *me->expand = false;
2078 macro_tokens_add (exp, &mts[0]);
2083 macro_expand (const struct macro_token *mts, size_t n,
2084 const struct macro_expander *me,
2085 struct macro_tokens *exp)
2087 if (me->nesting_countdown <= 0)
2089 macro_error (me->stack, NULL, _("Maximum nesting level %d exceeded. "
2090 "(Use SET MNEST to change the limit.)"),
2091 settings_get_mnest ());
2092 for (size_t i = 0; i < n; i++)
2093 macro_tokens_add (exp, &mts[i]);
2097 for (size_t i = 0; i < n; )
2099 if (me->break_ && *me->break_)
2102 size_t consumed = macro_expand__ (&mts[i], n - i, me, exp);
2103 assert (consumed > 0 && i + consumed <= n);
2109 macro_call_expand (struct macro_call *mc, enum segmenter_mode segmenter_mode,
2110 const struct msg_location *call_loc,
2111 struct macro_tokens *exp)
2113 assert (mc->state == MC_FINISHED);
2116 struct stringi_map vars = STRINGI_MAP_INITIALIZER (vars);
2117 struct macro_expansion_stack stack0 = {
2118 .location = call_loc,
2120 struct macro_expansion_stack stack1 = {
2122 .name = mc->macro->name,
2123 .location = mc->macro->location,
2125 struct macro_expander me = {
2126 .macros = mc->macros,
2129 .segmenter_mode = segmenter_mode,
2133 .nesting_countdown = settings_get_mnest (),
2137 const struct macro_tokens *body = &mc->macro->body;
2138 macro_expand (body->mts, body->n, &me, exp);
2140 stringi_map_destroy (&vars);