Remove unneeded dependency on variable.h.
[pspp-builds.git] / src / data / value-labels.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., 51 Franklin Street, Fifth Floor, Boston, MA
18    02110-1301, USA. */
19
20 #include <config.h>
21
22 #include "value-labels.h"
23
24 #include <stdlib.h>
25
26 #include <data/variable.h>
27 #include <libpspp/alloc.h>
28 #include <libpspp/compiler.h>
29 #include <libpspp/hash.h>
30 #include <libpspp/message.h>
31 #include <libpspp/str.h>
32
33 static hsh_compare_func compare_int_val_lab;
34 static hsh_hash_func hash_int_val_lab;
35 static hsh_free_func free_int_val_lab;
36
37 struct atom;
38 static struct atom *atom_create (const char *string);
39 static void atom_destroy (struct atom *);
40 static char *atom_to_string (const struct atom *);
41
42 /* A set of value labels. */
43 struct val_labs 
44   {
45     int width;                  /* 0=numeric, otherwise string width. */
46     struct hsh_table *labels;   /* Hash table of `struct int_val_lab's. */
47   };
48
49 /* Creates and returns a new, empty set of value labels with the
50    given WIDTH, which must designate a numeric (0) or short
51    string (1...MAX_SHORT_STRING inclusive) width. */
52 struct val_labs *
53 val_labs_create (int width) 
54 {
55   struct val_labs *vls;
56
57   assert (width >= 0);
58
59   vls = xmalloc (sizeof *vls);
60   vls->width = width;
61   vls->labels = NULL;
62   return vls;
63 }
64
65 /* Creates and returns a new set of value labels identical to
66    VLS. */
67 struct val_labs *
68 val_labs_copy (const struct val_labs *vls) 
69 {
70   struct val_labs *copy;
71   struct val_labs_iterator *i;
72   struct val_lab *vl;
73
74   assert (vls != NULL);
75
76   copy = val_labs_create (vls->width);
77   for (vl = val_labs_first (vls, &i); vl != NULL;
78        vl = val_labs_next (vls, &i)) 
79     val_labs_add (copy, vl->value, vl->label);
80   return copy;
81 }
82
83 /* Changes the width of VLS to NEW_WIDTH.  If VLS is numeric,
84    NEW_WIDTH must be 0, otherwise it must be within the range
85    1...MAX_SHORT_STRING inclusive. */
86 void
87 val_labs_set_width (struct val_labs *vls, int new_width) 
88 {
89   assert (vls != NULL);
90   assert ((vls->width == 0) == (new_width == 0));
91
92   vls->width = new_width;
93 }
94
95 /* Destroys VLS. */
96 void
97 val_labs_destroy (struct val_labs *vls) 
98 {
99   if (vls != NULL) 
100     {
101       if (vls->labels != NULL)
102         hsh_destroy (vls->labels);
103       free (vls);
104     }
105 }
106
107 /* Removes all the value labels from VLS. */
108 void
109 val_labs_clear (struct val_labs *vls) 
110 {
111   assert (vls != NULL);
112
113   hsh_destroy (vls->labels);
114   vls->labels = NULL;
115 }
116
117 /* Returns the number of value labels in VLS. */
118 size_t
119 val_labs_count (const struct val_labs *vls) 
120 {
121   assert (vls != NULL);
122
123   if (vls->labels == NULL)
124     return 0;
125   else
126     return hsh_count (vls->labels);
127 }
128 \f
129 /* One value label in internal format. */
130 struct int_val_lab
131   {
132     union value value;          /* The value being labeled. */
133     struct atom *label;         /* A ref-counted string. */
134   };
135
136 /* Creates and returns an int_val_lab based on VALUE and
137    LABEL. */
138 static struct int_val_lab *
139 create_int_val_lab (struct val_labs *vls, union value value, const char *label) 
140 {
141   struct int_val_lab *ivl;
142
143   assert (label != NULL);
144   assert (vls->width <= MAX_SHORT_STRING);
145   
146   ivl = xmalloc (sizeof *ivl);
147   ivl->value = value;
148   if (vls->width > 0)
149     memset (ivl->value.s + vls->width, ' ', MAX_SHORT_STRING - vls->width);
150   ivl->label = atom_create (label);
151
152   return ivl;
153 }
154
155 /* If VLS does not already contain a value label for VALUE, adds
156    LABEL for it and returns nonzero.  Otherwise, returns zero.
157    Behavior is undefined if VLS's width is greater than
158    MAX_SHORT_STRING. */
159 int
160 val_labs_add (struct val_labs *vls, union value value, const char *label) 
161 {
162   struct int_val_lab *ivl;
163   void **vlpp;
164
165   assert (vls != NULL);
166   assert (vls->width <= MAX_SHORT_STRING);
167   assert (label != NULL);
168
169   if (vls->labels == NULL) 
170     vls->labels = hsh_create (8, compare_int_val_lab, hash_int_val_lab,
171                               free_int_val_lab, vls);
172
173   ivl = create_int_val_lab (vls, value, label);
174   vlpp = hsh_probe (vls->labels, ivl);
175   if (*vlpp == NULL) 
176     {
177       *vlpp = ivl;
178       return 1; 
179     }
180   else 
181     {
182       free_int_val_lab (ivl, vls);
183       return 0;
184     }
185 }
186
187 /* Sets LABEL as the value label for VALUE in VLS.  Returns zero
188    if there wasn't already a value label for VALUE, or nonzero if
189    there was.  Behavior is undefined if VLS's width is greater
190    than MAX_SHORT_STRING. */
191 int
192 val_labs_replace (struct val_labs *vls, union value value, const char *label) 
193 {
194   struct int_val_lab *ivl;
195
196   assert (vls != NULL);
197   assert (vls->width <= MAX_SHORT_STRING);
198   assert (label != NULL);
199
200   if (vls->labels == NULL)
201     {
202       val_labs_add (vls, value, label);
203       return 0;
204     }
205
206   ivl = hsh_replace (vls->labels, create_int_val_lab (vls, value, label));
207   if (ivl == NULL) 
208     return 0;
209   else 
210     {
211       free_int_val_lab (ivl, vls);
212       return 1;
213     }
214 }
215
216 /* Removes any value label for VALUE within VLS.  Returns nonzero
217    if a value label was removed. Behavior is undefined if VLS's
218    width is greater than MAX_SHORT_STRING. */
219 int 
220 val_labs_remove (struct val_labs *vls, union value value) 
221 {
222   assert (vls != NULL);
223   assert (vls->width <= MAX_SHORT_STRING);
224
225   if (vls->labels != NULL) 
226     {
227       struct int_val_lab *ivl = create_int_val_lab (vls, value, "");
228       int deleted = hsh_delete (vls->labels, ivl);
229       free (ivl);
230       return deleted;
231     }
232   else
233     return 0;
234 }
235
236 /* Searches VLS for a value label for VALUE.  If successful,
237    returns the label; otherwise, returns a null pointer.  If
238    VLS's width is greater than MAX_SHORT_STRING, always returns a
239    null pointer. */
240 char *
241 val_labs_find (const struct val_labs *vls, union value value) 
242 {
243   assert (vls != NULL);
244
245   if (vls->width > MAX_SHORT_STRING)
246     return NULL;
247
248   if (vls->labels != NULL) 
249     {
250       struct int_val_lab ivl, *vlp;
251
252       ivl.value = value;
253       vlp = hsh_find (vls->labels, &ivl);
254       if (vlp != NULL)
255         return atom_to_string (vlp->label);
256     }
257   return NULL;
258 }
259 \f
260 /* A value labels iterator. */
261 struct val_labs_iterator 
262   {
263     void **labels;              /* The labels, in order. */
264     void **lp;                  /* Current label. */
265     struct val_lab vl;          /* Structure presented to caller. */
266   };
267
268 /* Sets up *IP for iterating through the value labels in VLS in
269    no particular order.  Returns the first value label or a null
270    pointer if VLS is empty.  If the return value is non-null,
271    then val_labs_next() may be used to continue iterating or
272    val_labs_done() to free up the iterator.  Otherwise, neither
273    function may be called for *IP. */
274 struct val_lab *
275 val_labs_first (const struct val_labs *vls, struct val_labs_iterator **ip) 
276 {
277   struct val_labs_iterator *i;
278
279   assert (vls != NULL);
280   assert (ip != NULL);
281
282   if (vls->labels == NULL || vls->width > MAX_SHORT_STRING)
283     return NULL;
284
285   i = *ip = xmalloc (sizeof *i);
286   i->labels = hsh_data_copy (vls->labels);
287   i->lp = i->labels;
288   return val_labs_next (vls, ip);
289 }
290
291 /* Sets up *IP for iterating through the value labels in VLS in
292    sorted order of values.  Returns the first value label or a
293    null pointer if VLS is empty.  If the return value is
294    non-null, then val_labs_next() may be used to continue
295    iterating or val_labs_done() to free up the iterator.
296    Otherwise, neither function may be called for *IP. */
297 struct val_lab *
298 val_labs_first_sorted (const struct val_labs *vls,
299                        struct val_labs_iterator **ip)
300 {
301   struct val_labs_iterator *i;
302
303   assert (vls != NULL);
304   assert (ip != NULL);
305
306   if (vls->labels == NULL || vls->width > MAX_SHORT_STRING)
307     return NULL;
308
309   i = *ip = xmalloc (sizeof *i);
310   i->lp = i->labels = hsh_sort_copy (vls->labels);
311   return val_labs_next (vls, ip);
312 }
313
314 /* Returns the next value label in an iteration begun by
315    val_labs_first() or val_labs_first_sorted().  If the return
316    value is non-null, then val_labs_next() may be used to
317    continue iterating or val_labs_done() to free up the iterator.
318    Otherwise, neither function may be called for *IP. */
319 struct val_lab *
320 val_labs_next (const struct val_labs *vls, struct val_labs_iterator **ip)
321 {
322   struct val_labs_iterator *i;
323   struct int_val_lab *ivl;
324   
325   assert (vls != NULL);
326   assert (vls->width <= MAX_SHORT_STRING);
327   assert (ip != NULL);
328   assert (*ip != NULL);
329
330   i = *ip;
331   ivl = *i->lp++;
332   if (ivl != NULL) 
333     {
334       i->vl.value = ivl->value;
335       i->vl.label = atom_to_string (ivl->label);
336       return &i->vl;
337     }
338   else 
339     {
340       free (i->labels);
341       free (i);
342       *ip = NULL;
343       return NULL;
344     }
345 }
346
347 /* Discards the state for an incomplete iteration begun by
348    val_labs_first() or val_labs_first_sorted(). */
349 void 
350 val_labs_done (struct val_labs_iterator **ip) 
351 {
352   struct val_labs_iterator *i;
353
354   assert (ip != NULL);
355   assert (*ip != NULL);
356   
357   i = *ip;
358   free (i->labels);
359   free (i);
360   *ip = NULL;
361 }
362 \f
363 /* Compares two value labels and returns a strcmp()-type result. */
364 int
365 compare_int_val_lab (const void *a_, const void *b_, void *vls_)
366 {
367   const struct int_val_lab *a = a_;
368   const struct int_val_lab *b = b_;
369   const struct val_labs *vls = vls_;
370
371   if (vls->width == 0) 
372     return a->value.f < b->value.f ? -1 : a->value.f > b->value.f;
373   else
374     return memcmp (a->value.s, b->value.s, vls->width);
375 }
376
377 /* Hash a value label. */
378 unsigned
379 hash_int_val_lab (const void *vl_, void *vls_)
380 {
381   const struct int_val_lab *vl = vl_;
382   const struct val_labs *vls = vls_;
383
384   if (vls->width == 0)
385     return hsh_hash_double (vl->value.f);
386   else
387     return hsh_hash_bytes (vl->value.s, sizeof vl->value.s);
388 }
389
390 /* Free a value label. */
391 void
392 free_int_val_lab (void *vl_, void *vls_ UNUSED) 
393 {
394   struct int_val_lab *vl = vl_;
395
396   atom_destroy (vl->label);
397   free (vl);
398 }
399 \f
400 /* Atoms. */
401
402 /* An atom. */
403 struct atom 
404   {
405     char *string;               /* String value. */
406     unsigned ref_count;         /* Number of references. */
407   };
408
409 static hsh_compare_func compare_atoms;
410 static hsh_hash_func hash_atom;
411 static hsh_free_func free_atom;
412
413 /* Hash table of atoms. */
414 static struct hsh_table *atoms;
415
416 /* Creates and returns an atom for STRING. */
417 static struct atom *
418 atom_create (const char *string) 
419 {
420   struct atom a;
421   void **app;
422   
423   assert (string != NULL);
424           
425   if (atoms == NULL) 
426     atoms = hsh_create (8, compare_atoms, hash_atom, free_atom, NULL);
427
428   a.string = (char *) string;
429   app = hsh_probe (atoms, &a);
430   if (*app != NULL) 
431     {
432       struct atom *ap = *app;
433       ap->ref_count++;
434       return ap;
435     }
436   else
437     {
438       struct atom *ap = xmalloc (sizeof *ap);
439       ap->string = xstrdup (string);
440       ap->ref_count = 1;
441       *app = ap;
442       return ap;
443     }
444 }
445
446 /* Destroys ATOM. */
447 static void 
448 atom_destroy (struct atom *atom)
449 {
450   if (atom != NULL) 
451     {
452       assert (atom->ref_count > 0);
453       atom->ref_count--;
454       if (atom->ref_count == 0) 
455         hsh_force_delete (atoms, atom);
456     }
457 }
458
459 /* Returns the string associated with ATOM. */
460 static  char *
461 atom_to_string (const struct atom *atom) 
462 {
463   assert (atom != NULL);
464   
465   return atom->string;
466 }
467
468 /* A hsh_compare_func that compares A and B. */
469 static int
470 compare_atoms (const void *a_, const void *b_, void *aux UNUSED) 
471 {
472   const struct atom *a = a_;
473   const struct atom *b = b_;
474
475   return strcmp (a->string, b->string);
476 }
477
478 /* A hsh_hash_func that hashes ATOM. */
479 static unsigned
480 hash_atom (const void *atom_, void *aux UNUSED) 
481 {
482   const struct atom *atom = atom_;
483
484   return hsh_hash_string (atom->string);
485 }
486
487 /* A hsh_free_func that destroys ATOM. */
488 static void
489 free_atom (void *atom_, void *aux UNUSED) 
490 {
491   struct atom *atom = atom_;
492
493   free (atom->string);
494   free (atom);
495 }
496
497
498 /* Get a string representing the value.
499    That is, if it has a label, then return that label,
500    otherwise, if the value is alpha, then return the string for it,
501    else format it and return the formatted string
502 */
503 const char *
504 value_to_string (const union value *val, const struct variable *var)
505 {
506   char *s;
507   
508   assert (val != NULL);
509   assert (var != NULL);
510
511   s = val_labs_find (var->val_labs, *val);
512   if (s == NULL) 
513     {
514       static char buf[256];
515       if (var->width != 0) 
516         str_copy_buf_trunc (buf, sizeof buf, val->s, var->width);
517       else
518         snprintf(buf, 100, "%g", val->f);
519       s = buf;
520     }
521   
522   return s;
523 }