Cope with new location of upstream files
[pspp] / 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 (lexer))
101         goto error;
102       if (lex_integer (lexer) < 1 || lex_integer (lexer) > 65535)
103         {
104           msg (SE, _("Attribute array index must be between 1 and 65535."));
105           goto error;
106         }
107       *index = lex_integer (lexer);
108       lex_get (lexer);
109       if (!lex_force_match (lexer, T_RBRACK))
110         goto error;
111     }
112   else
113     *index = 0;
114   return name;
115
116 error:
117   free (name);
118   return NULL;
119 }
120
121 static bool
122 add_attribute (struct lexer *lexer, const char *dict_encoding,
123                struct attrset **sets, size_t n)
124 {
125   const char *value;
126   size_t index, i;
127   char *name;
128
129   name = parse_attribute_name (lexer, dict_encoding, &index);
130   if (name == NULL)
131     return false;
132   if (!lex_force_match (lexer, T_LPAREN) || !lex_force_string (lexer))
133     {
134       free (name);
135       return false;
136     }
137   value = lex_tokcstr (lexer);
138
139   for (i = 0; i < n; i++)
140     {
141       struct attribute *attr = attrset_lookup (sets[i], name);
142       if (attr == NULL)
143         {
144           attr = attribute_create (name);
145           attrset_add (sets[i], attr);
146         }
147       attribute_set_value (attr, index ? index - 1 : 0, value);
148     }
149
150   lex_get (lexer);
151   free (name);
152   return lex_force_match (lexer, T_RPAREN);
153 }
154
155 static bool
156 delete_attribute (struct lexer *lexer, const char *dict_encoding,
157                   struct attrset **sets, size_t n)
158 {
159   size_t index, i;
160   char *name;
161
162   name = parse_attribute_name (lexer, dict_encoding, &index);
163   if (name == NULL)
164     return false;
165
166   for (i = 0; i < n; i++)
167     {
168       struct attrset *set = sets[i];
169       if (index == 0)
170         attrset_delete (set, name);
171       else
172         {
173           struct attribute *attr = attrset_lookup (set, name);
174           if (attr != NULL)
175             {
176               attribute_del_value (attr, index - 1);
177               if (attribute_get_n_values (attr) == 0)
178                 attrset_delete (set, name);
179             }
180         }
181     }
182
183   free (name);
184   return true;
185 }
186
187 static enum cmd_result
188 parse_attributes (struct lexer *lexer, const char *dict_encoding,
189                   struct attrset **sets, size_t n)
190 {
191   enum { UNKNOWN, ADD, DELETE } command = UNKNOWN;
192   do
193     {
194       if (lex_match_phrase (lexer, "ATTRIBUTE="))
195         command = ADD;
196       else if (lex_match_phrase (lexer, "DELETE="))
197         command = DELETE;
198       else if (command == UNKNOWN)
199         {
200           lex_error_expecting (lexer, "ATTRIBUTE=", "DELETE=", NULL_SENTINEL);
201           return CMD_FAILURE;
202         }
203
204       if (!(command == ADD
205             ? add_attribute (lexer, dict_encoding, sets, n)
206             : delete_attribute (lexer, dict_encoding, sets, n)))
207         return CMD_FAILURE;
208     }
209   while (lex_token (lexer) != T_SLASH && lex_token (lexer) != T_ENDCMD);
210   return CMD_SUCCESS;
211 }