Fix assertion for proper Huffman merge pattern: 0 == 1 modulo 1.
[pspp] / src / mis-val.c
1 /* PSPP - computes sample statistics.
2    Copyright (C) 1997-9, 2000 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., 59 Temple Place - Suite 330, Boston, MA
18    02111-1307, USA. */
19
20 #include <config.h>
21 #include "error.h"
22 #include <stdlib.h>
23 #include "command.h"
24 #include "error.h"
25 #include "lexer.h"
26 #include "magic.h"
27 #include "str.h"
28 #include "var.h"
29
30 #include "debug-print.h"
31
32 /* Variables on MIS VAL. */
33 static struct variable **v;
34 static int nv;
35
36 /* Type of the variables on MIS VAL. */
37 static int type;
38
39 /* Width of string variables on MIS VAL. */
40 static size_t width;
41
42 /* Items to fill-in var structs with. */
43 static int miss_type;
44 static union value missing[3];
45
46 static int parse_varnames (void);
47 static int parse_numeric (void);
48 static int parse_alpha (void);
49
50 int
51 cmd_missing_values (void)
52 {
53   int i;
54
55   while (token != '.')
56     {
57       if (!parse_varnames ())
58         goto fail;
59
60       if (token != ')')
61         {
62           if ((type == NUMERIC && !parse_numeric ())
63               || (type == ALPHA && !parse_alpha ()))
64             goto fail;
65         }
66       else
67         miss_type = MISSING_NONE;
68
69       if (!lex_match (')'))
70         {
71           msg (SE, _("`)' expected after value specification."));
72           goto fail;
73         }
74
75       for (i = 0; i < nv; i++)
76         {
77           v[i]->miss_type = miss_type;
78           memcpy (v[i]->missing, missing, sizeof v[i]->missing);
79         }
80
81       lex_match ('/');
82       free (v);
83     }
84
85   return lex_end_of_command ();
86
87 fail:
88   free (v);
89   return CMD_PART_SUCCESS_MAYBE;
90 }
91
92 static int
93 parse_varnames (void)
94 {
95   int i;
96
97   if (!parse_variables (default_dict, &v, &nv, PV_SAME_TYPE))
98     return 0;
99   if (!lex_match ('('))
100     {
101       msg (SE, _("`(' expected after variable name%s."), nv > 1 ? "s" : "");
102       return 0;
103     }
104
105   type = v[0]->type;
106   if (type == NUMERIC)
107     return 1;
108
109   width = v[0]->width;
110   for (i = 1; i < nv; i++)
111     if (v[i]->type == ALPHA && v[i]->nv != 1)
112       {
113         msg (SE, _("Long string value specified."));
114         return 0;
115       }
116     else if (v[i]->type == ALPHA && (int) width != v[i]->width)
117       {
118         msg (SE, _("Short strings must be of equal width."));
119         return 0;
120       }
121
122   return 1;
123 }
124
125 /* Number or range? */
126 enum
127   {
128     MV_NOR_NOTHING,             /* Empty. */
129     MV_NOR_NUMBER,              /* Single number. */
130     MV_NOR_RANGE                /* Range. */
131   };
132
133 /* A single value or a range. */
134 struct num_or_range
135   {
136     int type;                   /* One of NOR_*. */
137     double d[2];                /* d[0]=lower bound or value, d[1]=upper bound. */
138   };
139
140 /* Parses something of the form <num>, or LO[WEST] THRU <num>, or
141    <num> THRU HI[GHEST], or <num> THRU <num>, and sets the appropriate
142    members of NOR.  Returns success. */
143 static int
144 parse_num_or_range (struct num_or_range * nor)
145 {
146   if (lex_match_id ("LO") || lex_match_id ("LOWEST"))
147     {
148       nor->type = MV_NOR_RANGE;
149       if (!lex_force_match_id ("THRU"))
150         return 0;
151       if (!lex_force_num ())
152         return 0;
153       nor->d[0] = LOWEST;
154       nor->d[1] = tokval;
155     }
156   else if (token == T_NUM)
157     {
158       nor->d[0] = tokval;
159       lex_get ();
160
161       if (lex_match_id ("THRU"))
162         {
163           nor->type = MV_NOR_RANGE;
164           if (lex_match_id ("HI") || lex_match_id ("HIGHEST"))
165             nor->d[1] = HIGHEST;
166           else
167             {
168               if (!lex_force_num ())
169                 return 0;
170               nor->d[1] = tokval;
171               lex_get ();
172
173               if (nor->d[0] > nor->d[1])
174                 {
175                   msg (SE, _("Range %g THRU %g is not valid because %g is "
176                              "greater than %g."),
177                        nor->d[0], nor->d[1], nor->d[0], nor->d[1]);
178                   return 0;
179                 }
180             }
181         }
182       else
183         nor->type = MV_NOR_NUMBER;
184     }
185   else
186     return -1;
187
188   return 1;
189 }
190
191 /* Parses a set of numeric missing values and stores them into
192    `missing[]' and `miss_type' global variables. */
193 static int
194 parse_numeric (void)
195 {
196   struct num_or_range set[3];
197   int r;
198
199   set[1].type = set[2].type = MV_NOR_NOTHING;
200
201   /* Get first number or range. */
202   r = parse_num_or_range (&set[0]);
203   if (r < 1)
204     {
205       if (r == -1)
206         msg (SE, _("Number or range expected."));
207       return 0;
208     }
209
210   /* Get second and third optional number or range. */
211   lex_match (',');
212   r = parse_num_or_range (&set[1]);
213   if (r == 1)
214     {
215       lex_match (',');
216       r = parse_num_or_range (&set[2]);
217     }
218   if (r == 0)
219     return 0;
220
221   /* Force range, if present, into set[0]. */
222   if (set[1].type == MV_NOR_RANGE)
223     {
224       struct num_or_range t = set[1];
225       set[1] = set[0];
226       set[0] = t;
227     }
228   if (set[2].type == MV_NOR_RANGE)
229     {
230       struct num_or_range t = set[2];
231       set[2] = set[0];
232       set[0] = t;
233     }
234   
235   /* Ensure there's not more than one range, or one range
236      plus one value. */
237   if (set[1].type == MV_NOR_RANGE || set[2].type == MV_NOR_RANGE)
238     {
239       msg (SE, _("At most one range can exist in the missing values "
240                  "for any one variable."));
241       return 0;
242     }
243   if (set[0].type == MV_NOR_RANGE && set[2].type != MV_NOR_NOTHING)
244     {
245       msg (SE, _("At most one individual value can be missing along "
246                  "with one range."));
247       return 0;
248     }
249
250   /* Set missing[] from set[]. */
251   if (set[0].type == MV_NOR_RANGE)
252     {
253       int x = 0;
254
255       if (set[0].d[0] == LOWEST)
256         {
257           miss_type = MISSING_LOW;
258           missing[x++].f = set[0].d[1];
259         }
260       else if (set[0].d[1] == HIGHEST)
261         {
262           miss_type = MISSING_HIGH;
263           missing[x++].f = set[0].d[0];
264         }
265       else
266         {
267           miss_type = MISSING_RANGE;
268           missing[x++].f = set[0].d[0];
269           missing[x++].f = set[0].d[1];
270         }
271
272       if (set[1].type == MV_NOR_NUMBER)
273         {
274           miss_type += 3;
275           missing[x].f = set[1].d[0];
276         }
277     }
278   else
279     {
280       if (set[0].type == MV_NOR_NUMBER)
281         {
282           miss_type = MISSING_1;
283           missing[0].f = set[0].d[0];
284         }
285       if (set[1].type == MV_NOR_NUMBER)
286         {
287           miss_type = MISSING_2;
288           missing[1].f = set[1].d[0];
289         }
290       if (set[2].type == MV_NOR_NUMBER)
291         {
292           miss_type = MISSING_3;
293           missing[2].f = set[2].d[0];
294         }
295     }
296
297   return 1;
298 }
299
300 static int
301 parse_alpha (void)
302 {
303   for (miss_type = 0; token == T_STRING && miss_type < 3; miss_type++)
304     {
305       if (ds_length (&tokstr) != width)
306         {
307           msg (SE, _("String is not of proper length."));
308           return 0;
309         }
310       strncpy (missing[miss_type].s, ds_c_str (&tokstr), MAX_SHORT_STRING);
311       lex_get ();
312       lex_match (',');
313     }
314   if (miss_type < 1)
315     {
316       msg (SE, _("String expected."));
317       return 0;
318     }
319
320   return 1;
321 }
322
323 /* Copy the missing values from variable SRC to variable DEST. */
324 void
325 copy_missing_values (struct variable *dest, const struct variable *src)
326 {
327   static const int n_values[MISSING_COUNT] = 
328     {
329       0, 1, 2, 3, 2, 1, 1, 3, 2, 2,
330     };
331     
332   assert (dest->width == src->width);
333   assert (src->miss_type >= 0 && src->miss_type < MISSING_COUNT);
334   
335   {
336     int i;
337
338     dest->miss_type = src->miss_type;
339     for (i = 0; i < n_values[src->miss_type]; i++)
340       if (src->type == NUMERIC)
341         dest->missing[i].f = src->missing[i].f;
342       else
343         memcpy (dest->missing[i].s, src->missing[i].s, src->width);
344   }
345 }