pintos-os.org Git - pspp/blob - src/language/dictionary/attributes.c

   1 /* PSPP - a program for statistical analysis.
   2    Copyright (C) 2008, 2010, 2011 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 <stdlib.h>
  20
  21 #include "data/attributes.h"
  22 #include "data/dataset.h"
  23 #include "data/dictionary.h"
  24 #include "data/variable.h"
  25 #include "language/command.h"
  26 #include "language/lexer/lexer.h"
  27 #include "language/lexer/variable-parser.h"
  28 #include "libpspp/message.h"
  29
  30 #include "gl/xalloc.h"
  31
  32 #include "gettext.h"
  33 #define _(msgid) gettext (msgid)
  34
  35 static enum cmd_result parse_attributes (struct lexer *,
  36                                          const char *dict_encoding,
  37                                          struct attrset **, size_t n);
  38
  39 /* Parses the DATAFILE ATTRIBUTE command. */
  40 int
  41 cmd_datafile_attribute (struct lexer *lexer, struct dataset *ds)
  42 {
  43   struct dictionary *dict = dataset_dict (ds);
  44   struct attrset *set = dict_get_attributes (dict);
  45   return parse_attributes (lexer, dict_get_encoding (dict), &set, 1);
  46 }
  47
  48 /* Parses the VARIABLE ATTRIBUTE command. */
  49 int
  50 cmd_variable_attribute (struct lexer *lexer, struct dataset *ds)
  51 {
  52   struct dictionary *dict = dataset_dict (ds);
  53   const char *dict_encoding = dict_get_encoding (dict);
  54
  55   do
  56     {
  57       struct variable **vars;
  58       struct attrset **sets;
  59       size_t n_vars, i;
  60       bool ok;
  61
  62       if (!lex_force_match_id (lexer, "VARIABLES")
  63           || !lex_force_match (lexer, T_EQUALS)
  64           || !parse_variables (lexer, dict, &vars, &n_vars, PV_NONE))
  65         return CMD_FAILURE;
  66
  67       sets = xmalloc (n_vars * sizeof *sets);
  68       for (i = 0; i < n_vars; i++)
  69         sets[i] = var_get_attributes (vars[i]);
  70
  71       ok = parse_attributes (lexer, dict_encoding, sets, n_vars);
  72       free (vars);
  73       free (sets);
  74       if (!ok)
  75         return CMD_FAILURE;
  76     }
  77   while (lex_match (lexer, T_SLASH));
  78
  79   return CMD_SUCCESS;
  80 }
  81
  82 /* Parses an attribute name and verifies that it is valid in DICT_ENCODING,
  83    optionally followed by an index inside square brackets.  Returns the
  84    attribute name or NULL if there was a parse error.  Stores the index into
  85    *INDEX. */
  86 static char *
  87 parse_attribute_name (struct lexer *lexer, const char *dict_encoding,
  88                       size_t *index)
  89 {
  90   char *name;
  91
  92   if (!lex_force_id (lexer)
  93       || !id_is_valid (lex_tokcstr (lexer), dict_encoding, true))
  94     return NULL;
  95   name = xstrdup (lex_tokcstr (lexer));
  96   lex_get (lexer);
  97
  98   if (lex_match (lexer, T_LBRACK))
  99     {
 100       if (!lex_force_int_range (lexer, NULL, 1, 65535))
 101         goto error;
 102       *index = lex_integer (lexer);
 103       lex_get (lexer);
 104       if (!lex_force_match (lexer, T_RBRACK))
 105         goto error;
 106     }
 107   else
 108     *index = 0;
 109   return name;
 110
 111 error:
 112   free (name);
 113   return NULL;
 114 }
 115
 116 static bool
 117 add_attribute (struct lexer *lexer, const char *dict_encoding,
 118                struct attrset **sets, size_t n)
 119 {
 120   const char *value;
 121   size_t index, i;
 122   char *name;
 123
 124   name = parse_attribute_name (lexer, dict_encoding, &index);
 125   if (name == NULL)
 126     return false;
 127   if (!lex_force_match (lexer, T_LPAREN) || !lex_force_string (lexer))
 128     {
 129       free (name);
 130       return false;
 131     }
 132   value = lex_tokcstr (lexer);
 133
 134   for (i = 0; i < n; i++)
 135     {
 136       struct attribute *attr = attrset_lookup (sets[i], name);
 137       if (attr == NULL)
 138         {
 139           attr = attribute_create (name);
 140           attrset_add (sets[i], attr);
 141         }
 142       attribute_set_value (attr, index ? index - 1 : 0, value);
 143     }
 144
 145   lex_get (lexer);
 146   free (name);
 147   return lex_force_match (lexer, T_RPAREN);
 148 }
 149
 150 static bool
 151 delete_attribute (struct lexer *lexer, const char *dict_encoding,
 152                   struct attrset **sets, size_t n)
 153 {
 154   size_t index, i;
 155   char *name;
 156
 157   name = parse_attribute_name (lexer, dict_encoding, &index);
 158   if (name == NULL)
 159     return false;
 160
 161   for (i = 0; i < n; i++)
 162     {
 163       struct attrset *set = sets[i];
 164       if (index == 0)
 165         attrset_delete (set, name);
 166       else
 167         {
 168           struct attribute *attr = attrset_lookup (set, name);
 169           if (attr != NULL)
 170             {
 171               attribute_del_value (attr, index - 1);
 172               if (attribute_get_n_values (attr) == 0)
 173                 attrset_delete (set, name);
 174             }
 175         }
 176     }
 177
 178   free (name);
 179   return true;
 180 }
 181
 182 static enum cmd_result
 183 parse_attributes (struct lexer *lexer, const char *dict_encoding,
 184                   struct attrset **sets, size_t n)
 185 {
 186   enum { UNKNOWN, ADD, DELETE } command = UNKNOWN;
 187   do
 188     {
 189       if (lex_match_phrase (lexer, "ATTRIBUTE="))
 190         command = ADD;
 191       else if (lex_match_phrase (lexer, "DELETE="))
 192         command = DELETE;
 193       else if (command == UNKNOWN)
 194         {
 195           lex_error_expecting (lexer, "ATTRIBUTE=", "DELETE=");
 196           return CMD_FAILURE;
 197         }
 198
 199       if (!(command == ADD
 200             ? add_attribute (lexer, dict_encoding, sets, n)
 201             : delete_attribute (lexer, dict_encoding, sets, n)))
 202         return CMD_FAILURE;
 203     }
 204   while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD);
 205   return CMD_SUCCESS;
 206 }