pintos-os.org Git - pspp/blob - src/language/control/define.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2021 Free Software Foundation, Inc.
   3
   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.
   8
   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.
  13
  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/>. */
  16
  17 #include <config.h>
  18
  19 #include <limits.h>
  20
  21 #include "language/command.h"
  22 #include "language/lexer/lexer.h"
  23 #include "language/lexer/macro.h"
  24 #include "language/lexer/scan.h"
  25 #include "language/lexer/token.h"
  26
  27 #include "gl/xalloc.h"
  28
  29 #include "gettext.h"
  30 #define _(msgid) gettext (msgid)
  31
  32 static bool
  33 force_macro_id (struct lexer *lexer)
  34 {
  35   return lex_token (lexer) == T_MACRO_ID || lex_force_id (lexer);
  36 }
  37
  38 static bool
  39 match_macro_id (struct lexer *lexer, const char *id)
  40 {
  41   if (id[0] != '!')
  42     return lex_match_id (lexer, id);
  43   else if (lex_token (lexer) == T_MACRO_ID
  44            && ss_equals_case (lex_tokss (lexer), ss_cstr (id)))
  45     {
  46       lex_get (lexer);
  47       return true;
  48     }
  49   else
  50     return false;
  51 }
  52
  53 static bool
  54 parse_quoted_token (struct lexer *lexer, struct token *token)
  55 {
  56   if (!lex_force_string (lexer))
  57     return false;
  58
  59   struct substring s = lex_tokss (lexer);
  60   struct string_lexer slex;
  61   string_lexer_init (&slex, s.string, s.length, SEG_MODE_INTERACTIVE);
  62   struct token another_token;
  63   if (!string_lexer_next (&slex, token)
  64       || string_lexer_next (&slex, &another_token))
  65     {
  66       token_destroy (token);
  67       token_destroy (&another_token);
  68       lex_error (lexer, _("String must contain exactly one token."));
  69       return false;
  70     }
  71   lex_get (lexer);
  72   return true;
  73 }
  74
  75 int
  76 cmd_define (struct lexer *lexer, struct dataset *ds UNUSED)
  77 {
  78   if (!force_macro_id (lexer))
  79     return CMD_FAILURE;
  80
  81   /* Parse macro name. */
  82   struct macro *m = xmalloc (sizeof *m);
  83   *m = (struct macro) { .name = ss_xstrdup (lex_tokss (lexer)) };
  84   lex_get (lexer);
  85
  86   if (!lex_force_match (lexer, T_LPAREN))
  87     goto error;
  88
  89   size_t allocated_params = 0;
  90   size_t n_keywords = 0;
  91   while (!lex_match (lexer, T_RPAREN))
  92     {
  93       if (m->n_params >= allocated_params)
  94         m->params = x2nrealloc (m->params, &allocated_params,
  95                                 sizeof *m->params);
  96
  97       struct macro_param *p = &m->params[m->n_params++];
  98       *p = (struct macro_param) { .expand_arg = true };
  99
 100       /* Parse parameter name. */
 101       if (match_macro_id (lexer, "!POSITIONAL"))
 102         {
 103           if (n_keywords)
 104             {
 105               lex_error (lexer, _("Positional parameters must precede "
 106                                   "keyword parameters."));
 107               goto error;
 108             }
 109           p->name = NULL;
 110         }
 111       else
 112         {
 113           n_keywords++;
 114
 115           if (!lex_force_id (lexer))
 116             goto error;
 117
 118           p->name = ss_xstrdup (lex_tokss (lexer));
 119           lex_get (lexer);
 120
 121           if (!lex_force_match (lexer, T_EQUALS))
 122             goto error;
 123         }
 124
 125       /* Parse default value. */
 126       if (match_macro_id (lexer, "!DEFAULT"))
 127         {
 128           if (!lex_force_match (lexer, T_LPAREN))
 129             goto error;
 130
 131           /* XXX Should this handle balanced inner parentheses? */
 132           while (!lex_match (lexer, T_RPAREN))
 133             {
 134               if (lex_token (lexer) == T_ENDCMD)
 135                 {
 136                   lex_error_expecting (lexer, ")");
 137                   goto error;
 138                 }
 139               tokens_add (&p->def, lex_next (lexer, 0));
 140               lex_get (lexer);
 141             }
 142         }
 143
 144       if (match_macro_id (lexer, "!NOEXPAND"))
 145         p->expand_arg = false;
 146
 147       if (match_macro_id (lexer, "!TOKENS"))
 148         {
 149           if (!lex_force_match (lexer, T_LPAREN)
 150               || !lex_force_int_range (lexer, "!TOKENS", 1, INT_MAX))
 151             goto error;
 152           p->arg_type = ARG_N_TOKENS;
 153           p->n_tokens = lex_integer (lexer);
 154           lex_get (lexer);
 155           if (!lex_force_match (lexer, T_RPAREN))
 156             goto error;
 157         }
 158       else if (match_macro_id (lexer, "!CHAREND"))
 159         {
 160           p->arg_type = ARG_CHAREND;
 161           p->charend = (struct token) { .type = T_STOP };
 162
 163           if (!lex_force_match (lexer, T_LPAREN)
 164               || !parse_quoted_token (lexer, &p->charend)
 165               || !lex_force_match (lexer, T_RPAREN))
 166             goto error;
 167         }
 168       else if (match_macro_id (lexer, "!ENCLOSE"))
 169         {
 170           p->arg_type = ARG_ENCLOSE;
 171           p->enclose[0] = p->enclose[1] = (struct token) { .type = T_STOP };
 172
 173           if (!lex_force_match (lexer, T_LPAREN)
 174               || !parse_quoted_token (lexer, &p->enclose[0])
 175               || !lex_force_match (lexer, T_COMMA)
 176               || !parse_quoted_token (lexer, &p->enclose[1])
 177               || !lex_force_match (lexer, T_RPAREN))
 178             goto error;
 179         }
 180       else if (match_macro_id (lexer, "!CMDEND"))
 181         p->arg_type = ARG_CMDEND;
 182       else
 183         {
 184           lex_error_expecting (lexer, "!TOKENS", "!CHAREND",
 185                                "!ENCLOSE", "!CMDEND");
 186           goto error;
 187         }
 188
 189       if (lex_token (lexer) != T_RPAREN && !lex_force_match (lexer, T_SLASH))
 190         goto error;
 191     }
 192
 193   struct string body = DS_EMPTY_INITIALIZER;
 194   while (!match_macro_id (lexer, "!ENDDEFINE"))
 195     {
 196       if (lex_token (lexer) != T_STRING)
 197         {
 198           lex_error (lexer, _("Expecting macro body or !ENDDEFINE"));
 199           ds_destroy (&body);
 200           goto error;
 201         }
 202
 203       ds_put_substring (&body, lex_tokss (lexer));
 204       ds_put_byte (&body, '\n');
 205       lex_get (lexer);
 206     }
 207   m->body = ds_ss (&body);
 208
 209   lex_define_macro (lexer, m);
 210
 211   return CMD_SUCCESS;
 212
 213 error:
 214   macro_destroy (m);
 215   return CMD_FAILURE;
 216 }