First step in making struct variable opaque: the boring mechanical
[pspp-builds.git] / src / language / dictionary / missing-values.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
3    Written by Ben Pfaff <blp@gnu.org>.
4
5    This program is free software; you can redistribute it and/or
6    modify it under the terms of the GNU General Public License as
7    published by the Free Software Foundation; either version 2 of the
8    License, or (at your option) any later version.
9
10    This program is distributed in the hope that it will be useful, but
11    WITHOUT ANY WARRANTY; without even the implied warranty of
12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13    General Public License for more details.
14
15    You should have received a copy of the GNU General Public License
16    along with this program; if not, write to the Free Software
17    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18    02110-1301, USA. */
19
20 #include <config.h>
21
22 #include <stdlib.h>
23
24 #include <data/data-in.h>
25 #include <data/procedure.h>
26 #include <data/variable.h>
27 #include <language/command.h>
28 #include <language/lexer/lexer.h>
29 #include <language/lexer/variable-parser.h>
30 #include <language/lexer/range-parser.h>
31 #include <libpspp/magic.h>
32 #include <libpspp/message.h>
33 #include <libpspp/message.h>
34 #include <libpspp/str.h>
35
36 #include "gettext.h"
37 #define _(msgid) gettext (msgid)
38
39 int
40 cmd_missing_values (struct lexer *lexer, struct dataset *ds)
41 {
42   struct variable **v;
43   size_t nv;
44
45   int retval = CMD_FAILURE;
46   bool deferred_errors = false;
47
48   while (lex_token (lexer) != '.')
49     {
50       size_t i;
51
52       if (!parse_variables (lexer, dataset_dict (ds), &v, &nv, PV_NONE)) 
53         goto done;
54
55       if (!lex_match (lexer, '('))
56         {
57           lex_error (lexer, _("expecting `('"));
58           goto done;
59         }
60
61       for (i = 0; i < nv; i++)
62         var_clear_missing_values (v[i]);
63
64       if (!lex_match (lexer, ')')) 
65         {
66           struct missing_values mv;
67
68           for (i = 0; i < nv; i++)
69             if (var_get_type (v[i]) != var_get_type (v[0]))
70               {
71                 const struct variable *n = var_is_numeric (v[0]) ? v[0] : v[i];
72                 const struct variable *s = var_is_numeric (v[0]) ? v[i] : v[0];
73                 msg (SE, _("Cannot mix numeric variables (e.g. %s) and "
74                            "string variables (e.g. %s) within a single list."),
75                      var_get_name (n), var_get_name (s));
76                 goto done;
77               }
78
79           if (var_is_numeric (v[0])) 
80             {
81               mv_init (&mv, 0);
82               while (!lex_match (lexer, ')'))
83                 {
84                   enum fmt_type type = var_get_print_format (v[0])->type;
85                   double x, y;
86                   bool ok;
87
88                   if (!parse_num_range (lexer, &x, &y, &type))
89                     goto done;
90                   
91                   ok = (x == y
92                         ? mv_add_num (&mv, x)
93                         : mv_add_num_range (&mv, x, y));
94                   if (!ok)
95                     deferred_errors = true;
96
97                   lex_match (lexer, ',');
98                 }
99             }
100           else 
101             {
102               struct string value;
103
104               mv_init (&mv, MAX_SHORT_STRING);
105               while (!lex_match (lexer, ')')) 
106                 {
107                   if (!lex_force_string (lexer))
108                     {
109                       deferred_errors = true;
110                       break;
111                     }
112                   
113                   ds_init_string (&value, lex_tokstr (lexer));
114
115                   if (ds_length (&value) > MAX_SHORT_STRING) 
116                     {
117                       ds_truncate (&value, MAX_SHORT_STRING);
118                       msg (SE, _("Truncating missing value to short string "
119                                  "length (%d characters)."),
120                            MAX_SHORT_STRING);
121                     }
122                   else
123                     ds_rpad (&value, MAX_SHORT_STRING, ' ');
124
125                   if (!mv_add_str (&mv, ds_data (&value)))
126                     deferred_errors = true;
127                   ds_destroy (&value);
128
129                   lex_get (lexer);
130                   lex_match (lexer, ',');
131                 }
132             }
133           
134           for (i = 0; i < nv; i++) 
135             {
136               if (!mv_is_resizable (&mv, var_get_width (v[i]))) 
137                 {
138                   msg (SE, _("Missing values provided are too long to assign "
139                              "to variable of width %d."),
140                        var_get_width (v[i]));
141                   deferred_errors = true;
142                 }
143               else 
144                 {
145                   struct missing_values tmp;
146                   mv_copy (&tmp, &mv);
147                   mv_resize (&tmp, var_get_width (v[i]));
148                   var_set_missing_values (v[i], &tmp);
149                 }
150             }
151         }
152
153       lex_match (lexer, '/');
154       free (v);
155       v = NULL;
156     }
157   retval = lex_end_of_command (lexer);
158   
159  done:
160   free (v);
161   if (deferred_errors)
162     retval = CMD_FAILURE;
163   return retval;
164 }
165