1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2009, 2010, 2011, 2012 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 "data/value-labels.h"
20
21 #include <stdlib.h>
22
23 #include "data/data-out.h"
24 #include "data/value.h"
25 #include "data/variable.h"
26 #include "libpspp/array.h"
27 #include "libpspp/cast.h"
28 #include "libpspp/compiler.h"
29 #include "libpspp/hash-functions.h"
30 #include "libpspp/hmap.h"
31 #include "libpspp/intern.h"
32 #include "libpspp/message.h"
33 #include "libpspp/str.h"
34
35 #include "gl/xalloc.h"
36
37 /* Creates and returns a new, empty set of value labels with the
38 given WIDTH. */
39 struct val_labs *
val_labs_create(int width)40 val_labs_create (int width)
41 {
42 struct val_labs *vls = xmalloc (sizeof *vls);
43 vls->width = width;
44 hmap_init (&vls->labels);
45 return vls;
46 }
47
48 /* Creates and returns a new set of value labels identical to
49 VLS. Returns a null pointer if VLS is null. */
50 struct val_labs *
val_labs_clone(const struct val_labs * vls)51 val_labs_clone (const struct val_labs *vls)
52 {
53 struct val_labs *copy;
54 struct val_lab *label;
55
56 if (vls == NULL)
57 return NULL;
58
59 copy = val_labs_create (vls->width);
60 HMAP_FOR_EACH (label, struct val_lab, node, &vls->labels)
61 val_labs_add (copy, &label->value, label->escaped_label);
62 return copy;
63 }
64
65 /* Determines whether VLS's width can be changed to NEW_WIDTH,
66 using the rules checked by value_is_resizable. */
67 bool
val_labs_can_set_width(const struct val_labs * vls,int new_width)68 val_labs_can_set_width (const struct val_labs *vls, int new_width)
69 {
70 struct val_lab *label;
71
72 HMAP_FOR_EACH (label, struct val_lab, node, &vls->labels)
73 if (!value_is_resizable (&label->value, vls->width, new_width))
74 return false;
75
76 return true;
77 }
78
79 /* Changes the width of VLS to NEW_WIDTH. The original and new
80 width must be both numeric or both string. */
81 void
val_labs_set_width(struct val_labs * vls,int new_width)82 val_labs_set_width (struct val_labs *vls, int new_width)
83 {
84 assert (val_labs_can_set_width (vls, new_width));
85 if (value_needs_resize (vls->width, new_width))
86 {
87 struct val_lab *label;
88 HMAP_FOR_EACH (label, struct val_lab, node, &vls->labels)
89 value_resize (&label->value, vls->width, new_width);
90 }
91 vls->width = new_width;
92 }
93
94 /* Destroys VLS. */
95 void
val_labs_destroy(struct val_labs * vls)96 val_labs_destroy (struct val_labs *vls)
97 {
98 if (vls != NULL)
99 {
100 val_labs_clear (vls);
101 hmap_destroy (&vls->labels);
102 free (vls);
103 }
104 }
105
106 /* Removes all the value labels from VLS. */
107 void
val_labs_clear(struct val_labs * vls)108 val_labs_clear (struct val_labs *vls)
109 {
110 struct val_lab *label, *next;
111
112 HMAP_FOR_EACH_SAFE (label, next, struct val_lab, node, &vls->labels)
113 {
114 hmap_delete (&vls->labels, &label->node);
115 value_destroy (&label->value, vls->width);
116 intern_unref (label->label);
117 intern_unref (label->escaped_label);
118 free (label);
119 }
120 }
121
122 /* Returns the width of VLS. */
123 int
val_labs_get_width(const struct val_labs * vls)124 val_labs_get_width (const struct val_labs *vls)
125 {
126 return vls->width;
127 }
128
129 /* Returns the number of value labels in VLS.
130 Returns 0 if VLS is null. */
131 size_t
val_labs_count(const struct val_labs * vls)132 val_labs_count (const struct val_labs *vls)
133 {
134 return vls == NULL ? 0 : hmap_count (&vls->labels);
135 }
136
137 static void
set_label(struct val_lab * lab,const char * escaped_label)138 set_label (struct val_lab *lab, const char *escaped_label)
139 {
140 lab->escaped_label = intern_new (escaped_label);
141 if (strstr (escaped_label, "\\n") == NULL)
142 lab->label = intern_ref (lab->escaped_label);
143 else
144 {
145 struct string s;
146 const char *p;
147
148 ds_init_empty (&s);
149 ds_extend (&s, intern_strlen (lab->escaped_label));
150 for (p = escaped_label; *p != '\0'; p++)
151 {
152 char c = *p;
153 if (c == '\\' && p[1] == 'n')
154 {
155 c = '\n';
156 p++;
157 }
158 ds_put_byte (&s, c);
159 }
160 lab->label = intern_new (ds_cstr (&s));
161 ds_destroy (&s);
162 }
163 }
164
165 static void
do_add_val_lab(struct val_labs * vls,const union value * value,const char * escaped_label)166 do_add_val_lab (struct val_labs *vls, const union value *value,
167 const char *escaped_label)
168 {
169 struct val_lab *lab = xmalloc (sizeof *lab);
170 value_clone (&lab->value, value, vls->width);
171 set_label (lab, escaped_label);
172 hmap_insert (&vls->labels, &lab->node, value_hash (value, vls->width, 0));
173 }
174
175 /* If VLS does not already contain a value label for VALUE, adds the UTF-8
176 encoded LABEL for it and returns true. Otherwise, returns false.
177
178 In LABEL, the two-byte sequence "\\n" is interpreted as a new-line. */
179 bool
val_labs_add(struct val_labs * vls,const union value * value,const char * label)180 val_labs_add (struct val_labs *vls, const union value *value,
181 const char *label)
182 {
183 const struct val_lab *lab = val_labs_lookup (vls, value);
184 if (lab == NULL)
185 {
186 do_add_val_lab (vls, value, label);
187 return true;
188 }
189 else
190 return false;
191 }
192
193 /* Sets LABEL as the value label for VALUE in VLS, replacing any
194 existing label for VALUE.
195
196 In LABEL, the two-byte sequence "\\n" is interpreted as a new-line. */
197 void
val_labs_replace(struct val_labs * vls,const union value * value,const char * label)198 val_labs_replace (struct val_labs *vls, const union value *value,
199 const char *label)
200 {
201 struct val_lab *vl = val_labs_lookup (vls, value);
202 if (vl != NULL)
203 {
204 intern_unref (vl->label);
205 intern_unref (vl->escaped_label);
206 set_label (vl, label);
207 }
208 else
209 do_add_val_lab (vls, value, label);
210 }
211
212 /* Removes LABEL from VLS. */
213 void
val_labs_remove(struct val_labs * vls,struct val_lab * label)214 val_labs_remove (struct val_labs *vls, struct val_lab *label)
215 {
216 hmap_delete (&vls->labels, &label->node);
217 value_destroy (&label->value, vls->width);
218 intern_unref (label->label);
219 intern_unref (label->escaped_label);
220 free (label);
221 }
222
223 /* Searches VLS for a value label for VALUE. If successful, returns the string
224 used as the label, as a UTF-8 encoded string in a format suitable for
225 output. Otherwise, returns a null pointer. Returns a null pointer if VLS
226 is null. */
227 const char *
val_labs_find(const struct val_labs * vls,const union value * value)228 val_labs_find (const struct val_labs *vls, const union value *value)
229 {
230 const struct val_lab *label = val_labs_lookup (vls, value);
231 return label ? label->label : NULL;
232 }
233
234 /* Searches VLS for a value label for VALUE. If successful,
235 returns the value label; otherwise, returns a null pointer.
236 Returns a null pointer if VLS is null. */
237 static struct val_lab *
val_labs_lookup__(const struct val_labs * vls,const union value * value,unsigned int hash)238 val_labs_lookup__ (const struct val_labs *vls, const union value *value,
239 unsigned int hash)
240 {
241 struct val_lab *label;
242
243 HMAP_FOR_EACH_WITH_HASH (label, struct val_lab, node, hash, &vls->labels)
244 if (value_equal (&label->value, value, vls->width))
245 return label;
246
247 return NULL;
248 }
249
250 /* Searches VLS for a value label for VALUE. If successful,
251 returns the value label; otherwise, returns a null pointer.
252 Returns a null pointer if VLS is null. */
253 struct val_lab *
val_labs_lookup(const struct val_labs * vls,const union value * value)254 val_labs_lookup (const struct val_labs *vls, const union value *value)
255 {
256 return (vls == NULL ? NULL
257 : val_labs_lookup__ (vls, value, value_hash (value, vls->width, 0)));
258 }
259
260 /* Searches VLS for a value label whose label is exactly LABEL. If successful,
261 returns the corresponding value. Otherwise, returns a null pointer.
262
263 Returns a null pointer if VLS is null.
264
265 This function is O(n) in the number of labels in VLS. */
266 const union value *
val_labs_find_value(const struct val_labs * vls,const char * label_)267 val_labs_find_value (const struct val_labs *vls, const char *label_)
268 {
269 const union value *value = NULL;
270
271 if (vls != NULL)
272 {
273 const struct val_lab *vl;
274 const char *label;
275
276 label = intern_new (label_);
277 HMAP_FOR_EACH (vl, struct val_lab, node, &vls->labels)
278 if (vl->label == label)
279 {
280 value = &vl->value;
281 break;
282 }
283 intern_unref (label);
284 }
285
286 return value;
287 }
288
289 /* Returns the first value label in VLS, in arbitrary order, or a
290 null pointer if VLS is empty or if VLS is a null pointer. If
291 the return value is non-null, then val_labs_next() may be used
292 to continue iterating. */
293 const struct val_lab *
val_labs_first(const struct val_labs * vls)294 val_labs_first (const struct val_labs *vls)
295 {
296 return vls ? HMAP_FIRST (struct val_lab, node, &vls->labels) : NULL;
297 }
298
299 /* Returns the next value label in an iteration begun by
300 val_labs_first(). If the return value is non-null, then
301 val_labs_next() may be used to continue iterating. */
302 const struct val_lab *
val_labs_next(const struct val_labs * vls,const struct val_lab * label)303 val_labs_next (const struct val_labs *vls, const struct val_lab *label)
304 {
305 return HMAP_NEXT (label, struct val_lab, node, &vls->labels);
306 }
307
308 static int
compare_labels_by_value_3way(const void * a_,const void * b_,const void * vls_)309 compare_labels_by_value_3way (const void *a_, const void *b_, const void *vls_)
310 {
311 const struct val_lab *const *a = a_;
312 const struct val_lab *const *b = b_;
313 const struct val_labs *vls = vls_;
314 return value_compare_3way (&(*a)->value, &(*b)->value, vls->width);
315 }
316
317 /* Allocates and returns an array of pointers to value labels
318 that is sorted in increasing order by value. The array has
319 val_labs_count(VLS) elements. The caller is responsible for
320 freeing the array. */
321 const struct val_lab **
val_labs_sorted(const struct val_labs * vls)322 val_labs_sorted (const struct val_labs *vls)
323 {
324 if (vls != NULL)
325 {
326 const struct val_lab *label;
327 const struct val_lab **labels;
328 size_t i;
329
330 labels = xmalloc (val_labs_count (vls) * sizeof *labels);
331 i = 0;
332 HMAP_FOR_EACH (label, struct val_lab, node, &vls->labels)
333 labels[i++] = label;
334 assert (i == val_labs_count (vls));
335 sort (labels, val_labs_count (vls), sizeof *labels,
336 compare_labels_by_value_3way, vls);
337 return labels;
338 }
339 else
340 return NULL;
341 }
342
343 /* Returns a hash value that represents all of the labels in VLS, starting from
344 BASIS. */
345 unsigned int
val_labs_hash(const struct val_labs * vls,unsigned int basis)346 val_labs_hash (const struct val_labs *vls, unsigned int basis)
347 {
348 const struct val_lab *label;
349 unsigned int hash;
350
351 hash = hash_int (val_labs_count (vls), basis);
352 HMAP_FOR_EACH (label, struct val_lab, node, &vls->labels)
353 hash ^= value_hash (&label->value, vls->width,
354 hash_string (label->label, basis));
355 return hash;
356 }
357
358 /* Returns true if A and B contain the same values with the same labels,
359 false if they differ in some way. */
360 bool
val_labs_equal(const struct val_labs * a,const struct val_labs * b)361 val_labs_equal (const struct val_labs *a, const struct val_labs *b)
362 {
363 const struct val_lab *label;
364
365 if (val_labs_count (a) != val_labs_count (b))
366 return false;
367
368 if (a == NULL || b == NULL)
369 return true;
370
371 if (a->width != b->width)
372 return false;
373
374 HMAP_FOR_EACH (label, struct val_lab, node, &a->labels)
375 {
376 struct val_lab *label2 = val_labs_lookup__ (b, &label->value,
377 label->node.hash);
378 if (!label2 || label->label != label2->label)
379 return false;
380 }
381
382 return true;
383 }
384