X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Flexer%2Fmacro.c;h=e5805f035670b33e7b6f62aea55b58a623818ad4;hb=e784ed9c161b6b7aec1402de566e6c09cb2031e0;hp=a6d08b917d8c476ae72a1f9295e38f1abb675540;hpb=99e99bc433add91bc30f340895307122dfba9366;p=pspp diff --git a/src/language/lexer/macro.c b/src/language/lexer/macro.c index a6d08b917d..e5805f0356 100644 --- a/src/language/lexer/macro.c +++ b/src/language/lexer/macro.c @@ -334,6 +334,8 @@ classify_token (enum token_type type) case T_RPAREN: case T_LBRACK: case T_RBRACK: + case T_LCURLY: + case T_RCURLY: return TC_PUNCT; case T_PLUS: @@ -341,6 +343,7 @@ classify_token (enum token_type type) case T_ASTERISK: case T_SLASH: case T_EQUALS: + case T_COLON: case T_AND: case T_OR: case T_NOT: @@ -359,6 +362,7 @@ classify_token (enum token_type type) return TC_BINOP; case T_COMMA: + case T_SEMICOLON: return TC_COMMA; } @@ -498,9 +502,6 @@ macro_set_add (struct macro_set *set, struct macro *m) enum mc_state { - /* Error state. */ - MC_ERROR, - /* Accumulating tokens in mc->params toward the end of any type of argument. */ MC_ARG, @@ -604,38 +605,74 @@ mc_add_arg (struct macro_call *mc, const struct macro_token *mt, const struct msg_location *loc) { const struct macro_param *p = mc->param; + struct macro_tokens **argp = &mc->args[p - mc->macro->params]; const struct token *token = &mt->token; - if ((token->type == T_ENDCMD || token->type == T_STOP) - && p->arg_type != ARG_CMDEND) + if (token->type == T_ENDCMD || token->type == T_STOP) { - mc_error (mc, loc, - _("Unexpected end of command reading argument %s " - "to macro %s."), mc->param->name, mc->macro->name); + if (*argp) + { + switch (p->arg_type) + { + case ARG_CMDEND: + /* This is OK, it's the expected way to end the argument. */ + break; - mc->state = MC_ERROR; - return -1; + case ARG_N_TOKENS: + mc_error (mc, loc, + ngettext (_("Reached end of command expecting %zu " + "more token in argument %s to macro %s."), + _("Reached end of command expecting %zu " + "more tokens in argument %s to macro %s."), + p->n_tokens - (*argp)->n), + p->n_tokens - (*argp)->n, p->name, mc->macro->name); + break; + + case ARG_CHAREND: + case ARG_ENCLOSE: + { + char *end = token_to_string (&p->end); + mc_error (mc, loc, _("Reached end of command expecting \"%s\" " + "in argument %s to macro %s."), + end, p->name, mc->macro->name); + free (end); + } + break; + } + } + + /* The end of a command ends the current argument, precludes any further + arguments, and is not itself part of the argument. */ + return mc_finished (mc); } mc->n_tokens++; - struct macro_tokens **argp = &mc->args[p - mc->macro->params]; if (!*argp) *argp = xzalloc (sizeof **argp); bool add_token; /* Should we add 'mt' to the current arg? */ bool next_arg; /* Should we advance to the next arg? */ - if (p->arg_type == ARG_N_TOKENS) + switch (p->arg_type) { + case ARG_N_TOKENS: next_arg = (*argp)->n + 1 >= p->n_tokens; add_token = true; - } - else - { - next_arg = (p->arg_type == ARG_CMDEND - ? token->type == T_ENDCMD || token->type == T_STOP - : token_equal (token, &p->end)); + break; + + case ARG_CHAREND: + case ARG_ENCLOSE: + next_arg = token_equal (token, &p->end); add_token = !next_arg; + break; + + case ARG_CMDEND: + next_arg = false; + add_token = true; + break; + + default: + NOT_REACHED (); } if (add_token) @@ -660,8 +697,7 @@ mc_expected (struct macro_call *mc, const struct macro_token *actual, mc->param->name, mc->macro->name); free (expected_s); - mc->state = MC_ERROR; - return -1; + return mc_finished (mc); } static int @@ -669,15 +705,21 @@ mc_enclose (struct macro_call *mc, const struct macro_token *mt, const struct msg_location *loc) { const struct token *token = &mt->token; - mc->n_tokens++; - - if (token_equal (&mc->param->start, token)) + const struct macro_param *p = mc->param; + if (token_equal (&p->start, token)) { + mc->n_tokens++; + + struct macro_tokens **argp = &mc->args[p - mc->macro->params]; + if (!*argp) + *argp = xzalloc (sizeof **argp); mc->state = MC_ARG; return 0; } - - return mc_expected (mc, mt, loc, &mc->param->start); + else if (p->positional && (token->type == T_ENDCMD || token->type == T_STOP)) + return mc_finished (mc); + else + return mc_expected (mc, mt, loc, &p->start); } static const struct macro_param * @@ -711,17 +753,14 @@ mc_keyword (struct macro_call *mc, const struct macro_token *mt, token->string); if (p) { - size_t arg_index = p - mc->macro->params; - mc->param = p; - if (mc->args[arg_index]) - { - mc_error (mc, loc, - _("Argument %s multiply specified in call to macro %s."), - p->name, mc->macro->name); - mc->state = MC_ERROR; - return -1; - } + struct macro_tokens **argp = &mc->args[p - mc->macro->params]; + if (*argp) + mc_error (mc, loc, + _("Argument %s multiply specified in call to macro %s."), + p->name, mc->macro->name); + *argp = xzalloc (sizeof **argp); + mc->param = p; mc->n_tokens++; mc->state = MC_EQUALS; return 0; @@ -734,11 +773,9 @@ static int mc_equals (struct macro_call *mc, const struct macro_token *mt, const struct msg_location *loc) { - const struct token *token = &mt->token; - mc->n_tokens++; - - if (token->type == T_EQUALS) + if (mt->token.type == T_EQUALS) { + mc->n_tokens++; mc->state = mc->param->arg_type == ARG_ENCLOSE ? MC_ENCLOSE : MC_ARG; return 0; } @@ -837,9 +874,6 @@ macro_call_add (struct macro_call *mc, const struct macro_token *mt, { switch (mc->state) { - case MC_ERROR: - return -1; - case MC_ARG: return mc_add_arg (mc, mt, loc); @@ -957,12 +991,7 @@ parse_function_args (const struct macro_expander *me, const char *function, struct string_array *args) { - if (n < 2 || mts[1].token.type != T_LPAREN) - { - macro_error (me->stack, n > 1 ? &mts[1] : NULL, - _("`(' expected following %s."), function); - return 0; - } + assert (n >= 2 && mts[1].token.type == T_LPAREN); for (size_t i = 2; i < n; ) { @@ -1014,7 +1043,8 @@ unquote_string (const char *s, enum segmenter_mode segmenter_mode, return false; } - ds_put_substring (content, token1.string); + if (content) + ds_put_substring (content, token1.string); token_uninit (&token1); return true; } @@ -1061,7 +1091,6 @@ expand_macro_function (const struct macro_expander *me, MF_HEAD, MF_INDEX, MF_LENGTH, - MF_NULL, MF_QUOTE, MF_SUBSTR, MF_TAIL, @@ -1075,7 +1104,6 @@ expand_macro_function (const struct macro_expander *me, [MF_HEAD] = { "!HEAD", 1, 1 }, [MF_INDEX] = { "!INDEX", 2, 2 }, [MF_LENGTH] = { "!LENGTH", 1, 1 }, - [MF_NULL] = { "!NULL", 0, 0 }, [MF_QUOTE] = { "!QUOTE", 1, 1 }, [MF_SUBSTR] = { "!SUBSTR", 2, 3 }, [MF_TAIL] = { "!TAIL", 1, 1 }, @@ -1083,7 +1111,16 @@ expand_macro_function (const struct macro_expander *me, [MF_UPCASE] = { "!UPCASE", 1, 1 }, }; - /* Is this a macro function? */ + if (lex_id_match_n (ss_cstr ("!NULL"), input[0].token.string, 4)) + return 1; + + if (n_input < 2 || input[1].token.type != T_LPAREN) + { + /* Only consider macro functions when the name is followed by '('. */ + return 0; + } + + /* Is this a macro function name? */ const struct macro_function *mf; for (mf = mfs; ; mf++) { @@ -1098,13 +1135,14 @@ expand_macro_function (const struct macro_expander *me, } enum macro_function_id id = mf - mfs; - if (id == MF_NULL) - return 1; struct string_array args = STRING_ARRAY_INITIALIZER; size_t n_consumed = parse_function_args (me, input, n_input, mf->name, &args); if (!n_consumed) - return 0; + { + string_array_destroy (&args); + return 0; + } if (args.n < mf->min_args || args.n > mf->max_args) { @@ -1127,6 +1165,7 @@ expand_macro_function (const struct macro_expander *me, mf->name); else NOT_REACHED (); + string_array_destroy (&args); return 0; } @@ -1805,6 +1844,7 @@ macro_expand_do (const struct macro_token *tokens, size_t n_tokens, macro_expand (p, do_end - p, &subme, exp); } + macro_tokens_uninit (&items); return do_end - tokens + 1; } else if (p < end && p->token.type == T_EQUALS)