Whitespace changes for the benefit of xgettext.
[pspp-builds.git] / src / data / caseproto.c
1 /* PSPP - a program for statistical analysis.
2    Copyright (C) 2009 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/caseproto.h>
20 #include <data/val-type.h>
21 #include <data/value.h>
22 #include <libpspp/array.h>
23 #include <libpspp/assertion.h>
24 #include <libpspp/pool.h>
25
26 #include "minmax.h"
27
28 static struct caseproto *caseproto_unshare (struct caseproto *);
29 static bool try_init_long_strings (const struct caseproto *,
30                                    size_t first, size_t last, union value[]);
31 static void init_long_strings (const struct caseproto *,
32                                size_t first, size_t last, union value[]);
33 static void destroy_long_strings (const struct caseproto *,
34                                   size_t first, size_t last, union value[]);
35 static size_t count_long_strings (const struct caseproto *,
36                                   size_t idx, size_t count);
37
38 /* Returns the number of bytes to allocate for a struct caseproto
39    with room for N_WIDTHS elements in its widths[] array. */
40 static inline size_t
41 caseproto_size (size_t n_widths)
42 {
43   return (offsetof (struct caseproto, widths)
44           + n_widths * sizeof (((struct caseproto *) NULL)->widths[0]));
45 }
46
47 /* Creates and returns a case prototype that initially has no
48    widths. */
49 struct caseproto *
50 caseproto_create (void)
51 {
52   enum { N_ALLOCATE = 4 };
53   struct caseproto *proto = xmalloc (caseproto_size (N_ALLOCATE));
54   proto->ref_cnt = 1;
55   proto->long_strings = NULL;
56   proto->n_long_strings = 0;
57   proto->n_widths = 0;
58   proto->allocated_widths = N_ALLOCATE;
59   return proto;
60 }
61
62 static void
63 do_unref (void *proto_)
64 {
65   struct caseproto *proto = proto_;
66   caseproto_unref (proto);
67 }
68
69 /* Creates and returns a new reference to PROTO.  When POOL is
70    destroyed, the new reference will be destroyed (unrefed).  */
71 struct caseproto *
72 caseproto_ref_pool (const struct caseproto *proto_, struct pool *pool)
73 {
74   struct caseproto *proto = caseproto_ref (proto_);
75   pool_register (pool, do_unref, proto);
76   return proto;
77 }
78
79 /* Returns a replacement for PROTO that is unshared and has
80    enough room for at least N_WIDTHS widths before additional
81    memory is needed.  */
82 struct caseproto *
83 caseproto_reserve (struct caseproto *proto, size_t n_widths)
84 {
85   proto = caseproto_unshare (proto);
86   if (n_widths > proto->allocated_widths)
87     {
88       proto->allocated_widths *= MAX (proto->allocated_widths * 2, n_widths);
89       proto = xrealloc (proto, caseproto_size (proto->allocated_widths));
90     }
91   return proto;
92 }
93
94 /* Returns a replacement for PROTO with WIDTH appended.  */
95 struct caseproto *
96 caseproto_add_width (struct caseproto *proto, int width)
97 {
98   assert (width >= -1 && width <= MAX_STRING);
99
100   proto = caseproto_reserve (proto, proto->n_widths + 1);
101   proto->widths[proto->n_widths++] = width;
102   proto->n_long_strings += count_long_strings (proto, proto->n_widths - 1, 1);
103
104   return proto;
105 }
106
107 /* Returns a replacement for PROTO with the width at index IDX
108    replaced by WIDTH.  IDX may be greater than the current number
109    of widths in PROTO, in which case any gap is filled in by
110    widths of -1. */
111 struct caseproto *
112 caseproto_set_width (struct caseproto *proto, size_t idx, int width)
113 {
114   assert (width >= -1 && width <= MAX_STRING);
115
116   proto = caseproto_reserve (proto, idx + 1);
117   while (idx >= proto->n_widths)
118     proto->widths[proto->n_widths++] = -1;
119   proto->n_long_strings -= count_long_strings (proto, idx, 1);
120   proto->widths[idx] = width;
121   proto->n_long_strings += count_long_strings (proto, idx, 1);
122
123   return proto;
124 }
125
126 /* Returns a replacement for PROTO with WIDTH inserted just
127    before index BEFORE, or just after the last element if BEFORE
128    is the number of widths in PROTO. */
129 struct caseproto *
130 caseproto_insert_width (struct caseproto *proto, size_t before, int width)
131 {
132   assert (before <= proto->n_widths);
133
134   proto = caseproto_reserve (proto, proto->n_widths + 1);
135   proto->n_long_strings += value_needs_init (width);
136   insert_element (proto->widths, proto->n_widths, sizeof *proto->widths,
137                   before);
138   proto->widths[before] = width;
139   proto->n_widths++;
140
141   return proto;
142 }
143
144 /* Returns a replacement for PROTO with CNT widths removed
145    starting at index IDX. */
146 struct caseproto *
147 caseproto_remove_widths (struct caseproto *proto, size_t idx, size_t cnt)
148 {
149   assert (caseproto_range_is_valid (proto, idx, cnt));
150
151   proto = caseproto_unshare (proto);
152   proto->n_long_strings -= count_long_strings (proto, idx, cnt);
153   remove_range (proto->widths, proto->n_widths, sizeof *proto->widths,
154                 idx, cnt);
155   proto->n_widths -= cnt;
156   return proto;
157 }
158
159 /* Returns a replacement for PROTO in which the CNT widths
160    starting at index OLD_WIDTH now start at index NEW_WIDTH, with
161    other widths shifting out of the way to make room. */
162 struct caseproto *
163 caseproto_move_widths (struct caseproto *proto,
164                        size_t old_start, size_t new_start,
165                        size_t cnt)
166 {
167   assert (caseproto_range_is_valid (proto, old_start, cnt));
168   assert (caseproto_range_is_valid (proto, new_start, cnt));
169
170   proto = caseproto_unshare (proto);
171   move_range (proto->widths, proto->n_widths, sizeof *proto->widths,
172               old_start, new_start, cnt);
173   return proto;
174 }
175
176 /* Returns true if PROTO contains COUNT widths starting at index
177    OFS, false if any of those widths are out of range for
178    PROTO. */
179 bool
180 caseproto_range_is_valid (const struct caseproto *proto,
181                           size_t ofs, size_t count)
182 {
183   return (count <= proto->n_widths
184           && ofs <= proto->n_widths
185           && ofs + count <= proto->n_widths);
186 }
187
188 /* Returns true if A and B have the same widths along their
189    common length.  (When this is so, a case with prototype A may
190    be extended or truncated to have prototype B without having to
191    change any existing values, and vice versa.) */
192 bool
193 caseproto_is_conformable (const struct caseproto *a, const struct caseproto *b)
194 {
195   size_t min;
196   size_t i;
197
198   min = MIN (a->n_widths, b->n_widths);
199   for (i = 0; i < min; i++)
200     if (a->widths[i] != b->widths[i])
201       return false;
202   return true;
203 }
204
205 /* Returns true if the N widths starting at A_START in A are the
206    same as the N widths starting at B_START in B, false if any of
207    the corresponding widths differ. */
208 bool
209 caseproto_equal (const struct caseproto *a, size_t a_start,
210                  const struct caseproto *b, size_t b_start,
211                  size_t n)
212 {
213   size_t i;
214
215   assert (caseproto_range_is_valid (a, a_start, n));
216   assert (caseproto_range_is_valid (b, b_start, n));
217   for (i = 0; i < n; i++)
218     if (a->widths[a_start + i] != b->widths[b_start + i])
219       return false;
220   return true;
221 }
222
223 /* Returns true if an array of values that is to be used for
224    data of the format specified in PROTO needs to be initialized
225    by calling caseproto_init_values, false if that step may be
226    skipped because such an initialization would be a no-op anyhow.
227
228    This optimization is useful only when a large number of
229    initializations of such arrays may be skipped as a group. */
230 bool
231 caseproto_needs_init_values (const struct caseproto *proto)
232 {
233   return proto->n_long_strings > 0;
234 }
235
236 /* Initializes the values in VALUES as required by PROTO, by
237    calling value_init() on each value for which this is required.
238    The data in VALUES have indeterminate contents until
239    explicitly written.
240
241    VALUES must have at least caseproto_get_n_widths(PROTO)
242    elements; only that many elements of VALUES are initialized.
243
244    The caller retains ownership of PROTO. */
245 void
246 caseproto_init_values (const struct caseproto *proto, union value values[])
247 {
248   init_long_strings (proto, 0, proto->n_long_strings, values);
249 }
250
251 /* Like caseproto_init_values, but returns false instead of
252    terminating if memory cannot be obtained. */
253 bool
254 caseproto_try_init_values (const struct caseproto *proto, union value values[])
255 {
256   return try_init_long_strings (proto, 0, proto->n_long_strings, values);
257 }
258
259 /* Initializes the data in VALUES that are in NEW but not in OLD,
260    destroys the data in VALUES that are in OLD but not NEW, and
261    does not modify the data in VALUES that are in both OLD and
262    NEW.  VALUES must previously have been initialized as required
263    by OLD using e.g. caseproto_init_values.  The data in VALUES
264    that are in NEW but not in OLD will have indeterminate
265    contents until explicitly written.
266
267    OLD and NEW must be conformable for this operation, as
268    reported by caseproto_is_conformable.
269
270    The caller retains ownership of OLD and NEW. */
271 void
272 caseproto_reinit_values (const struct caseproto *old,
273                          const struct caseproto *new, union value values[])
274 {
275   size_t old_n_long = old->n_long_strings;
276   size_t new_n_long = new->n_long_strings;
277
278   expensive_assert (caseproto_is_conformable (old, new));
279
280   if (new_n_long > old_n_long)
281     init_long_strings (new, old_n_long, new_n_long, values);
282   else if (new_n_long < old_n_long)
283     destroy_long_strings (old, new_n_long, old_n_long, values);
284 }
285
286 /* Frees the values in VALUES as required by PROTO, by calling
287    value_destroy() on each value for which this is required.  The
288    values must previously have been initialized using
289    e.g. caseproto_init_values.
290
291    The caller retains ownership of PROTO. */
292 void
293 caseproto_destroy_values (const struct caseproto *proto, union value values[])
294 {
295   destroy_long_strings (proto, 0, proto->n_long_strings, values);
296 }
297
298 /* Copies COUNT values, whose widths are given by widths in PROTO
299    starting with index IDX, from SRC to DST.  The caller must
300    ensure that the values in SRC and DST were appropriately
301    initialized using e.g. caseproto_init_values. */
302 void
303 caseproto_copy (const struct caseproto *proto, size_t idx, size_t count,
304                 union value *dst, const union value *src)
305 {
306   size_t i;
307
308   assert (caseproto_range_is_valid (proto, idx, count));
309   for (i = 0; i < count; i++)
310     value_copy (&dst[idx + i], &src[idx + i], proto->widths[idx + i]);
311 }
312 \f
313 void
314 caseproto_free__ (struct caseproto *proto)
315 {
316   free (proto->long_strings);
317   free (proto);
318 }
319
320 void
321 caseproto_refresh_long_string_cache__ (const struct caseproto *proto_)
322 {
323   struct caseproto *proto = (struct caseproto *) proto_;
324   size_t n, i;
325
326   assert (proto->long_strings == NULL);
327   assert (proto->n_long_strings > 0);
328
329   proto->long_strings = xmalloc (proto->n_long_strings
330                                  * sizeof *proto->long_strings);
331   n = 0;
332   for (i = 0; i < proto->n_widths; i++)
333     if (proto->widths[i] > MAX_SHORT_STRING)
334       proto->long_strings[n++] = i;
335   assert (n == proto->n_long_strings);
336 }
337
338 static struct caseproto *
339 caseproto_unshare (struct caseproto *old)
340 {
341   struct caseproto *new;
342   if (old->ref_cnt > 1)
343     {
344       new = xmemdup (old, caseproto_size (old->allocated_widths));
345       new->ref_cnt = 1;
346       --old->ref_cnt;
347     }
348   else
349     {
350       new = old;
351       free (new->long_strings);
352     }
353   new->long_strings = NULL;
354   return new;
355 }
356
357 static bool
358 try_init_long_strings (const struct caseproto *proto,
359                        size_t first, size_t last, union value values[])
360 {
361   size_t i;
362
363   if (last > 0 && proto->long_strings == NULL)
364     caseproto_refresh_long_string_cache__ (proto);
365
366   for (i = first; i < last; i++)
367     {
368       size_t idx = proto->long_strings[i];
369       if (!value_try_init (&values[idx], proto->widths[idx]))
370         {
371           destroy_long_strings (proto, first, i, values);
372           return false;
373         }
374     }
375   return true;
376 }
377
378 static void
379 init_long_strings (const struct caseproto *proto,
380                    size_t first, size_t last, union value values[])
381 {
382   if (!try_init_long_strings (proto, first, last, values))
383     xalloc_die ();
384 }
385
386 static void
387 destroy_long_strings (const struct caseproto *proto, size_t first, size_t last,
388                       union value values[])
389 {
390   size_t i;
391
392   if (last > 0 && proto->long_strings == NULL)
393     caseproto_refresh_long_string_cache__ (proto);
394
395   for (i = first; i < last; i++)
396     {
397       size_t idx = proto->long_strings[i];
398       value_destroy (&values[idx], proto->widths[idx]);
399     }
400 }
401
402 static size_t
403 count_long_strings (const struct caseproto *proto, size_t idx, size_t count)
404 {
405   size_t n, i;
406
407   n = 0;
408   for (i = 0; i < count; i++)
409     n += proto->widths[idx + i] > MAX_SHORT_STRING;
410   return n;
411 }