1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2009 Free Software Foundation, Inc.
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.
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.
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/>. */
18 #include <data/value.h>
20 #include <data/val-type.h>
21 #include <data/variable.h>
22 #include <libpspp/hash.h>
23 #include <libpspp/pool.h>
24 #include <libpspp/str.h>
29 /* Copies the contents of string value SRC with width SRC_WIDTH
30 to string value DST with width DST_WIDTH. If SRC_WIDTH is
31 greater than DST_WIDTH, then only the first DST_WIDTH bytes
32 are copied; if DST_WIDTH is greater than SRC_WIDTH, then DST
33 is padded on the right with PAD bytes.
35 SRC and DST must be string values; that is, SRC_WIDTH and
36 DST_WIDTH must both be positive.
38 It is important that SRC_WIDTH and DST_WIDTH be the actual
39 widths with which SRC and DST were initialized. Passing,
40 e.g., smaller values in order to copy only a prefix of SRC or
41 modify only a prefix of DST will not work in every case. */
43 value_copy_rpad (union value *dst, int dst_width,
44 const union value *src, int src_width,
47 buf_copy_rpad (value_str_rw (dst, dst_width), dst_width,
48 value_str (src, src_width), src_width,
52 /* Copies the contents of null-terminated string SRC to string
53 value DST with width DST_WIDTH. If SRC is more than DST_WIDTH
54 bytes long, then only the first DST_WIDTH bytes are copied; if
55 DST_WIDTH is greater than the length of SRC, then DST is
56 padded on the right with PAD bytes.
58 DST must be a string value; that is, DST_WIDTH must be
61 It is important that DST_WIDTH be the actual width with which
62 DST was initialized. Passing, e.g., a smaller value in order
63 to modify only a prefix of DST will not work in every case. */
65 value_copy_str_rpad (union value *dst, int dst_width, const char *src,
68 value_copy_buf_rpad (dst, dst_width, src, strlen (src), pad);
71 /* Copies the SRC_LEN bytes at SRC to string value DST with width
72 DST_WIDTH. If SRC_LEN is greater than DST_WIDTH, then only
73 the first DST_WIDTH bytes are copied; if DST_WIDTH is greater
74 than SRC_LEN, then DST is padded on the right with PAD bytes.
76 DST must be a string value; that is, DST_WIDTH must be
79 It is important that DST_WIDTH be the actual width with which
80 DST was initialized. Passing, e.g., a smaller value in order
81 to modify only a prefix of DST will not work in every case. */
83 value_copy_buf_rpad (union value *dst, int dst_width,
84 const char *src, size_t src_len, char pad)
86 buf_copy_rpad (value_str_rw (dst, dst_width), dst_width, src, src_len, pad);
89 /* Sets V to the system-missing value for data of the given
92 value_set_missing (union value *v, int width)
99 memset (value_str_rw (v, width), ' ', width);
103 /* Compares A and B, which both have the given WIDTH, and returns
104 a strcmp()-type result. */
106 value_compare_3way (const union value *a, const union value *b, int width)
108 return (width == -1 ? 0
109 : width == 0 ? (a->f < b->f ? -1 : a->f > b->f)
110 : memcmp (value_str (a, width), value_str (b, width), width));
113 /* Returns true if A and B, which must both have the given WIDTH,
114 have equal contents, false if their contents differ. */
116 value_equal (const union value *a, const union value *b, int width)
118 return (width == -1 ? true
119 : width == 0 ? a->f == b->f
120 : !memcmp (value_str (a, width), value_str (b, width), width));
123 /* Returns a hash of the data in VALUE, which must have the given
124 WIDTH, folding BASIS into the hash value calculation. */
126 value_hash (const union value *value, int width, unsigned int basis)
128 return (width == -1 ? basis
129 : width == 0 ? hash_double (value->f, basis)
130 : hash_bytes (value_str (value, width), width, basis));
133 /* Tests whether VALUE may be resized from OLD_WIDTH to
134 NEW_WIDTH, using the following rules that match those for
135 resizing missing values and value labels. First, OLD_WIDTH
136 and NEW_WIDTH must be both numeric or both string. Second, if
137 NEW_WIDTH is less than OLD_WIDTH, then the bytes that would be
138 trimmed off the right end of VALUE must be all spaces. */
140 value_is_resizable (const union value *value, int old_width, int new_width)
142 if (old_width == new_width)
144 else if (val_type_from_width (old_width) != val_type_from_width (new_width))
148 const char *str = value_str (value, old_width);
151 for (i = new_width; i < old_width; i++)
158 /* Resizes VALUE from OLD_WIDTH to NEW_WIDTH. The arguments must
159 satisfy the rules specified above for value_is_resizable. */
161 value_resize (union value *value, int old_width, int new_width)
163 assert (value_is_resizable (value, old_width, new_width));
164 if (new_width != old_width)
167 value_init (&tmp, new_width);
168 value_copy_rpad (&tmp, new_width, value, old_width, ' ');
169 value_destroy (value, old_width);
174 /* Returns true if resizing a value from OLD_WIDTH to NEW_WIDTH
175 actually changes anything, false otherwise. If false is
176 returned, calls to value_resize() with the specified
177 parameters may be omitted without any ill effects.
179 This is generally useful only if many values can skip being
180 resized from OLD_WIDTH to NEW_WIDTH. Otherwise you might as
181 well just call value_resize directly. */
183 value_needs_resize (int old_width, int new_width)
185 assert (val_type_from_width (old_width) == val_type_from_width (new_width));
187 /* We need to call value_resize if either the new width is
188 longer than the old width (in which case the new characters
189 must be set to spaces) or if either width is a long string.
190 (We could omit resizing if both the old and new widths were
191 long and the new width was shorter, but we choose to do so
192 anyway in hopes of saving memory.) */
193 return (old_width != new_width
194 && (new_width > old_width
195 || old_width > MAX_SHORT_STRING
196 || new_width > MAX_SHORT_STRING));
199 /* Same as value_init, except that memory for VALUE (if
200 necessary) is allocated from POOL and will be freed
201 automatically when POOL is destroyed.
203 VALUE must not be freed manually by calling value_destroy. If
204 it needs to be resized, it must be done using
205 value_resize_pool instead of value_resize. */
207 value_init_pool (struct pool *pool, union value *value, int width)
209 if (width > MAX_SHORT_STRING)
210 value->long_string = pool_alloc_unaligned (pool, width);
213 /* Same as value_resize, except that VALUE must have been
214 allocated from POOL using value_init_pool.
216 This function causes some memory in POOL to be wasted in some
217 cases (until the pool is freed), so it should only be done if
218 this is acceptable. */
220 value_resize_pool (struct pool *pool, union value *value,
221 int old_width, int new_width)
223 assert (value_is_resizable (value, old_width, new_width));
224 if (new_width > old_width)
226 if (new_width > MAX_SHORT_STRING)
228 char *new_long_string = pool_alloc_unaligned (pool, new_width);
229 memcpy (new_long_string, value_str (value, old_width), old_width);
230 value->long_string = new_long_string;
232 memset (value_str_rw (value, new_width) + old_width, ' ',
233 new_width - old_width);