X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Flanguage%2Flexer%2Fvariable-parser.c;h=14635a209eeb67692d9b6e2587877c3659d297d6;hb=de786d64f39e8d8c7a3b1d86fbd88ec2d6d19fa6;hp=514ce160f41b2e7fc751ddb508fc89d05f26e9b4;hpb=e2f99612bf4f4691623f16730eed3e55afdc54f0;p=pspp

diff --git a/src/language/lexer/variable-parser.c b/src/language/lexer/variable-parser.c
index 514ce160f4..14635a209e 100644
--- a/src/language/lexer/variable-parser.c
+++ b/src/language/lexer/variable-parser.c
@@ -1,5 +1,5 @@
 /* PSPP - a program for statistical analysis.
-   Copyright (C) 1997-9, 2000, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
+   Copyright (C) 1997-9, 2000, 2009, 2010, 2011, 2012, 2020 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -122,35 +122,42 @@ parse_variable (struct lexer *lexer, const struct dictionary *d)
 
 /* Parses a set of variables from dictionary D given options
    OPTS.  Resulting list of variables stored in *VAR and the
-   number of variables into *CNT.  Returns true only if
-   successful. */
+   number of variables into *N.  Returns true only if
+   successful.  The dictionary D must contain at least one
+   variable.  */
 bool
 parse_variables (struct lexer *lexer, const struct dictionary *d,
-			struct variable ***var,
-			size_t *cnt, int opts)
+                 struct variable ***var,
+                 size_t *n, int opts)
 {
   struct var_set *vs;
   int success;
 
   assert (d != NULL);
   assert (var != NULL);
-  assert (cnt != NULL);
+  assert (n != NULL);
 
   vs = var_set_create_from_dict (d);
-  success = parse_var_set_vars (lexer, vs, var, cnt, opts);
+  if (var_set_get_n (vs) == 0)
+    {
+      *n = 0;
+      var_set_destroy (vs);
+      return false;
+    }
+  success = parse_var_set_vars (lexer, vs, var, n, opts);
   var_set_destroy (vs);
   return success;
 }
 
 /* Parses a set of variables from dictionary D given options
    OPTS.  Resulting list of variables stored in *VARS and the
-   number of variables into *VAR_CNT.  Returns true only if
+   number of variables into *N_VARS.  Returns true only if
    successful.  Same behavior as parse_variables, except that all
    allocations are taken from the given POOL. */
 bool
 parse_variables_pool (struct lexer *lexer, struct pool *pool,
 		const struct dictionary *dict,
-		struct variable ***vars, size_t *var_cnt, int opts)
+		struct variable ***vars, size_t *n_vars, int opts)
 {
   int retval;
 
@@ -160,7 +167,7 @@ parse_variables_pool (struct lexer *lexer, struct pool *pool,
      later. */
   assert (!(opts & PV_APPEND));
 
-  retval = parse_variables (lexer, dict, vars, var_cnt, opts);
+  retval = parse_variables (lexer, dict, vars, n_vars, opts);
   if (retval)
     pool_register (pool, free, *vars);
   return retval;
@@ -288,7 +295,7 @@ parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
     {
       size_t i;
 
-      included = xcalloc (var_set_get_cnt (vs), sizeof *included);
+      included = xcalloc (var_set_get_n (vs), sizeof *included);
       for (i = 0; i < *nv; i++)
         {
           size_t index;
@@ -304,7 +311,7 @@ parse_var_set_vars (struct lexer *lexer, const struct var_set *vs,
     {
       if (lex_match (lexer, T_ALL))
         add_variables (v, nv, &mv, included, pv_opts,
-                       vs, 0, var_set_get_cnt (vs) - 1, DC_ORDINARY);
+                       vs, 0, var_set_get_n (vs) - 1, DC_ORDINARY);
       else
         {
           enum dict_class class;
@@ -461,6 +468,7 @@ parse_DATA_LIST_vars (struct lexer *lexer, const struct dictionary *dict,
   struct stringi_set set;
 
   char *name1 = NULL;
+  char *name2 = NULL;
 
   bool ok = false;
 
@@ -504,7 +512,9 @@ parse_DATA_LIST_vars (struct lexer *lexer, const struct dictionary *dict,
           int root_len1, root_len2;
           unsigned long int number;
 
-          char *name2 = parse_DATA_LIST_var (lexer, dict);
+          name2 = parse_DATA_LIST_var (lexer, dict);
+          if (!name2)
+            goto exit;
 
           root_len1 = extract_numeric_suffix (name1, &num1, &n_digits1);
           if (root_len1 == 0)
@@ -541,6 +551,7 @@ parse_DATA_LIST_vars (struct lexer *lexer, const struct dictionary *dict,
           free (name1);
           name1 = NULL;
           free (name2);
+          name2 = NULL;
 	}
       else
 	{
@@ -575,6 +586,7 @@ exit:
       *n_varsp = 0;
 
       free (name1);
+      free (name2);
     }
   return ok;
 }
@@ -685,11 +697,140 @@ parse_mixed_vars_pool (struct lexer *lexer, const struct dictionary *dict, struc
   return retval;
 }
 
+/* Frees the N var_syntax structures in VS, as well as VS itself. */
+void
+var_syntax_destroy (struct var_syntax *vs, size_t n)
+{
+  for (size_t i = 0; i < n; i++)
+    {
+      free (vs[i].first);
+      free (vs[i].last);
+    }
+  free (vs);
+}
+
+/* Parses syntax for variables and variable ranges from LEXER.  If successful,
+   initializes *VS to the beginning of an array of var_syntax structs and *N_VS
+   to the number of elements in the array and returns true.  On error, sets *VS
+   to NULL and *N_VS to 0 and returns false. */
+bool
+var_syntax_parse (struct lexer *lexer, struct var_syntax **vs, size_t *n_vs)
+{
+  *vs = NULL;
+  *n_vs = 0;
+
+  if (lex_token (lexer) != T_ID)
+    {
+      lex_error (lexer, _("expecting variable name"));
+      goto error;
+    }
+
+  size_t allocated_vs = 0;
+  do
+    {
+      if (allocated_vs >= *n_vs)
+        *vs = x2nrealloc (*vs, &allocated_vs, sizeof **vs);
+      struct var_syntax *new = &(*vs)[(*n_vs)++];
+      *new = (struct var_syntax) { .first = ss_xstrdup (lex_tokss (lexer)) };
+      lex_get (lexer);
+
+      if (lex_match (lexer, T_TO))
+        {
+          if (lex_token (lexer) != T_ID)
+            {
+              lex_error (lexer, _("expecting variable name"));
+              goto error;
+            }
+
+          new->last = ss_xstrdup (lex_tokss (lexer));
+          lex_get (lexer);
+        }
+    }
+  while (lex_token (lexer) == T_ID);
+  return true;
+
+error:
+  var_syntax_destroy (*vs, *n_vs);
+  *vs = NULL;
+  *n_vs = 0;
+  return false;
+}
+
+/* Looks up the N_VS var syntax structs in VS in DICT, translating them to an
+   array of variables.  If successful, initializes *VARS to the beginning of an
+   array of pointers to variables and *N_VARS to the length of the array and
+   returns true.  On error, sets *VARS to NULL and *N_VARS to 0.
+
+   For the moment, only honors PV_NUMERIC in OPTS. */
+bool
+var_syntax_evaluate (const struct var_syntax *vs, size_t n_vs,
+                     const struct dictionary *dict,
+                     struct variable ***vars, size_t *n_vars, int opts)
+{
+  assert (!(opts & ~PV_NUMERIC));
+
+  *vars = NULL;
+  *n_vars = 0;
+
+  size_t allocated_vars = 0;
+  for (size_t i = 0; i < n_vs; i++)
+    {
+      struct variable *first = dict_lookup_var (dict, vs[i].first);
+      if (!first)
+        {
+          msg (SE, _("%s is not a variable name."), vs[i].first);
+          goto error;
+        }
+
+      struct variable *last = (vs[i].last
+                               ? dict_lookup_var (dict, vs[i].last)
+                               : first);
+      if (!last)
+        {
+          msg (SE, _("%s is not a variable name."), vs[i].last);
+          goto error;
+        }
+
+      size_t first_idx = var_get_dict_index (first);
+      size_t last_idx = var_get_dict_index (last);
+      if (last_idx < first_idx)
+        {
+          msg (SE, _("%s TO %s is not valid syntax since %s "
+                     "precedes %s in the dictionary."),
+               vs[i].first, vs[i].last,
+               vs[i].first, vs[i].last);
+          goto error;
+        }
+
+      for (size_t j = first_idx; j <= last_idx; j++)
+        {
+          struct variable *v = dict_get_var (dict, j);
+          if (opts & PV_NUMERIC && !var_is_numeric (v))
+            {
+              msg (SW, _("%s is not a numeric variable."), var_get_name (v));
+              goto error;
+            }
+
+          if (*n_vars >= allocated_vars)
+            *vars = x2nrealloc (*vars, &allocated_vars, sizeof **vars);
+          (*vars)[(*n_vars)++] = v;
+        }
+    }
+
+  return true;
+
+error:
+  free (*vars);
+  *vars = NULL;
+  *n_vars = 0;
+  return false;
+}
+
 /* A set of variables. */
 struct var_set
   {
     bool names_must_be_ids;
-    size_t (*get_cnt) (const struct var_set *);
+    size_t (*get_n) (const struct var_set *);
     struct variable *(*get_var) (const struct var_set *, size_t idx);
     bool (*lookup_var_idx) (const struct var_set *, const char *, size_t *);
     void (*destroy) (struct var_set *);
@@ -698,11 +839,11 @@ struct var_set
 
 /* Returns the number of variables in VS. */
 size_t
-var_set_get_cnt (const struct var_set *vs)
+var_set_get_n (const struct var_set *vs)
 {
   assert (vs != NULL);
 
-  return vs->get_cnt (vs);
+  return vs->get_n (vs);
 }
 
 /* Return variable with index IDX in VS.
@@ -711,7 +852,7 @@ static struct variable *
 var_set_get_var (const struct var_set *vs, size_t idx)
 {
   assert (vs != NULL);
-  assert (idx < var_set_get_cnt (vs));
+  assert (idx < var_set_get_n (vs));
 
   return vs->get_var (vs, idx);
 }
@@ -755,11 +896,11 @@ var_set_get_names_must_be_ids (const struct var_set *vs)
 
 /* Returns the number of variables in VS. */
 static size_t
-dict_var_set_get_cnt (const struct var_set *vs)
+dict_var_set_get_n (const struct var_set *vs)
 {
   struct dictionary *d = vs->aux;
 
-  return dict_get_var_cnt (d);
+  return dict_get_n_vars (d);
 }
 
 /* Return variable with index IDX in VS.
@@ -802,7 +943,7 @@ var_set_create_from_dict (const struct dictionary *d)
 {
   struct var_set *vs = xmalloc (sizeof *vs);
   vs->names_must_be_ids = dict_get_names_must_be_ids (d);
-  vs->get_cnt = dict_var_set_get_cnt;
+  vs->get_n = dict_var_set_get_n;
   vs->get_var = dict_var_set_get_var;
   vs->lookup_var_idx = dict_var_set_lookup_var_idx;
   vs->destroy = dict_var_set_destroy;
@@ -814,17 +955,17 @@ var_set_create_from_dict (const struct dictionary *d)
 struct array_var_set
   {
     struct variable *const *var;/* Array of variables. */
-    size_t var_cnt;             /* Number of elements in var. */
+    size_t n_vars;              /* Number of elements in var. */
     struct hmapx vars_by_name;  /* Variables hashed by name. */
   };
 
 /* Returns the number of variables in VS. */
 static size_t
-array_var_set_get_cnt (const struct var_set *vs)
+array_var_set_get_n (const struct var_set *vs)
 {
   struct array_var_set *avs = vs->aux;
 
-  return avs->var_cnt;
+  return avs->n_vars;
 }
 
 /* Return variable with index IDX in VS.
@@ -869,9 +1010,9 @@ array_var_set_destroy (struct var_set *vs)
   free (vs);
 }
 
-/* Returns a variable set based on the VAR_CNT variables in VAR. */
+/* Returns a variable set based on the N_VARS variables in VAR. */
 struct var_set *
-var_set_create_from_array (struct variable *const *var, size_t var_cnt)
+var_set_create_from_array (struct variable *const *var, size_t n_vars)
 {
   struct var_set *vs;
   struct array_var_set *avs;
@@ -879,15 +1020,15 @@ var_set_create_from_array (struct variable *const *var, size_t var_cnt)
 
   vs = xmalloc (sizeof *vs);
   vs->names_must_be_ids = true;
-  vs->get_cnt = array_var_set_get_cnt;
+  vs->get_n = array_var_set_get_n;
   vs->get_var = array_var_set_get_var;
   vs->lookup_var_idx = array_var_set_lookup_var_idx;
   vs->destroy = array_var_set_destroy;
   vs->aux = avs = xmalloc (sizeof *avs);
   avs->var = var;
-  avs->var_cnt = var_cnt;
+  avs->n_vars = n_vars;
   hmapx_init (&avs->vars_by_name);
-  for (i = 0; i < var_cnt; i++)
+  for (i = 0; i < n_vars; i++)
     {
       const char *name = var_get_name (var[i]);
       size_t idx;
@@ -916,7 +1057,7 @@ lex_match_variable (struct lexer *lexer, const struct dictionary *dict, const st
 
   *var = parse_variable_const  (lexer, dict);
 
-  if ( *var == NULL)
+  if (*var == NULL)
     return false;
   return true;
 }
@@ -952,12 +1093,12 @@ parse_internal_interaction (struct lexer *lexer, const struct dictionary *dict,
 
   assert (v);
 
-  if ( *iact == NULL)
+  if (*iact == NULL)
     *iact = interaction_create (v);
   else
     interaction_add_variable (*iact, v);
 
-  if ( lex_match (lexer, T_ASTERISK) || lex_match (lexer, T_BY))
+  if (lex_match (lexer, T_ASTERISK) || lex_match (lexer, T_BY))
     {
       return parse_internal_interaction (lexer, dict, iact, iact);
     }