1 /* PSPP - computes sample statistics.
2 Copyright (C) 1997-9, 2000, 2006 Free Software Foundation, Inc.
3 Written by Ben Pfaff <blp@gnu.org>.
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.
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.
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
28 #include <libpspp/va_copy.h>
29 #include <libpspp/alloc.h>
30 #include <libpspp/message.h>
35 /* Reverses the order of NBYTES bytes at address P, thus converting
36 between little- and big-endian byte orders. */
38 buf_reverse (char *p, size_t nbytes)
40 char *h = p, *t = &h[nbytes - 1];
52 /* Finds the last NEEDLE of length NEEDLE_LEN in a HAYSTACK of length
53 HAYSTACK_LEN. Returns a pointer to the needle found. */
55 buf_find_reverse (const char *haystack, size_t haystack_len,
56 const char *needle, size_t needle_len)
59 for (i = haystack_len - needle_len; i >= 0; i--)
60 if (!memcmp (needle, &haystack[i], needle_len))
61 return (char *) &haystack[i];
65 /* Compares the SIZE bytes in A to those in B, disregarding case,
66 and returns a strcmp()-type result. */
68 buf_compare_case (const char *a_, const char *b_, size_t size)
70 const unsigned char *a = (unsigned char *) a_;
71 const unsigned char *b = (unsigned char *) b_;
75 unsigned char ac = toupper (*a++);
76 unsigned char bc = toupper (*b++);
79 return ac > bc ? 1 : -1;
85 /* Compares A of length A_LEN to B of length B_LEN. The shorter
86 string is considered to be padded with spaces to the length of
89 buf_compare_rpad (const char *a, size_t a_len, const char *b, size_t b_len)
94 min_len = a_len < b_len ? a_len : b_len;
95 result = memcmp (a, b, min_len);
104 for (idx = min_len; idx < b_len; idx++)
106 return ' ' > b[idx] ? 1 : -1;
110 for (idx = min_len; idx < a_len; idx++)
112 return a[idx] > ' ' ? 1 : -1;
118 /* Compares strin A to string B. The shorter string is
119 considered to be padded with spaces to the length of the
122 str_compare_rpad (const char *a, const char *b)
124 return buf_compare_rpad (a, strlen (a), b, strlen (b));
127 /* Copies string SRC to buffer DST, of size DST_SIZE bytes.
128 DST is truncated to DST_SIZE bytes or padded on the right with
131 buf_copy_str_rpad (char *dst, size_t dst_size, const char *src)
133 size_t src_len = strlen (src);
134 if (src_len >= dst_size)
135 memcpy (dst, src, dst_size);
138 memcpy (dst, src, src_len);
139 memset (&dst[src_len], ' ', dst_size - src_len);
143 /* Copies string SRC to buffer DST, of size DST_SIZE bytes.
144 DST is truncated to DST_SIZE bytes or padded on the left with
147 buf_copy_str_lpad (char *dst, size_t dst_size, const char *src)
149 size_t src_len = strlen (src);
150 if (src_len >= dst_size)
151 memcpy (dst, src, dst_size);
154 size_t pad_cnt = dst_size - src_len;
155 memset (&dst[0], ' ', pad_cnt);
156 memcpy (dst + pad_cnt, src, src_len);
160 /* Copies buffer SRC, of SRC_SIZE bytes, to DST, of DST_SIZE bytes.
161 DST is truncated to DST_SIZE bytes or padded on the right with
164 buf_copy_rpad (char *dst, size_t dst_size,
165 const char *src, size_t src_size)
167 if (src_size >= dst_size)
168 memmove (dst, src, dst_size);
171 memmove (dst, src, src_size);
172 memset (&dst[src_size], ' ', dst_size - src_size);
176 /* Copies string SRC to string DST, which is in a buffer DST_SIZE
178 Truncates DST to DST_SIZE - 1 characters or right-pads with
179 spaces to DST_SIZE - 1 characters if necessary. */
181 str_copy_rpad (char *dst, size_t dst_size, const char *src)
183 size_t src_len = strlen (src);
184 if (src_len < dst_size - 1)
186 memcpy (dst, src, src_len);
187 memset (&dst[src_len], ' ', dst_size - 1 - src_len);
190 memcpy (dst, src, dst_size - 1);
191 dst[dst_size - 1] = 0;
194 /* Copies SRC to DST, which is in a buffer DST_SIZE bytes long.
195 Truncates DST to DST_SIZE - 1 characters, if necessary. */
197 str_copy_trunc (char *dst, size_t dst_size, const char *src)
199 size_t src_len = strlen (src);
200 assert (dst_size > 0);
201 if (src_len + 1 < dst_size)
202 memcpy (dst, src, src_len + 1);
205 memcpy (dst, src, dst_size - 1);
206 dst[dst_size - 1] = '\0';
210 /* Copies buffer SRC, of SRC_LEN bytes,
211 to DST, which is in a buffer DST_SIZE bytes long.
212 Truncates DST to DST_SIZE - 1 characters, if necessary. */
214 str_copy_buf_trunc (char *dst, size_t dst_size,
215 const char *src, size_t src_size)
218 assert (dst_size > 0);
220 dst_len = src_size < dst_size ? src_size : dst_size - 1;
221 memcpy (dst, src, dst_len);
225 /* Converts each character in S to uppercase. */
227 str_uppercase (char *s)
229 for (; *s != '\0'; s++)
230 *s = toupper ((unsigned char) *s);
233 /* Converts each character in S to lowercase. */
235 str_lowercase (char *s)
237 for (; *s != '\0'; s++)
238 *s = tolower ((unsigned char) *s);
241 /* Initializes ST with initial contents S. */
243 ds_create (struct string *st, const char *s)
245 st->length = strlen (s);
246 st->capacity = MAX (8, st->length * 2);
247 st->string = xmalloc (st->capacity + 1);
248 strcpy (st->string, s);
251 /* Initializes ST, making room for at least CAPACITY characters. */
253 ds_init (struct string *st, size_t capacity)
256 st->capacity = MAX (8, capacity);
257 st->string = xmalloc (st->capacity + 1);
262 ds_destroy (struct string *st)
273 /* Swaps the contents of strings A and B. */
275 ds_swap (struct string *a, struct string *b)
277 struct string tmp = *a;
282 /* Initializes DST with the CNT characters from SRC starting at
285 ds_init_substring (struct string *dst,
286 const struct string *src, size_t idx, size_t cnt)
290 ds_assign_substring (dst, src, idx, cnt);
293 /* Copies SRC into DST.
294 DST and SRC may be the same string. */
296 ds_assign_string (struct string *dst, const struct string *src)
298 ds_assign_buffer (dst, ds_data (src), ds_length (src));
301 /* Replaces DST by CNT characters from SRC starting at position
303 DST and SRC may be the same string. */
305 ds_assign_substring (struct string *dst,
306 const struct string *src, size_t idx, size_t cnt)
308 if (idx < src->length)
309 ds_assign_buffer (dst, src->string + idx, MIN (cnt, src->length - idx));
314 /* Replaces DST by the LENGTH characters in SRC.
315 SRC may be a substring within DST. */
317 ds_assign_buffer (struct string *dst, const char *src, size_t length)
319 dst->length = length;
320 ds_extend (dst, length);
321 memmove (dst->string, src, length);
324 /* Replaces DST by null-terminated string SRC. SRC may overlap
327 ds_assign_c_str (struct string *dst, const char *src)
329 ds_assign_buffer (dst, src, strlen (src));
332 /* Truncates ST to zero length. */
334 ds_clear (struct string *st)
339 /* Ensures that ST can hold at least MIN_CAPACITY characters plus a null
342 ds_extend (struct string *st, size_t min_capacity)
344 if (min_capacity > st->capacity)
347 if (st->capacity < min_capacity)
348 st->capacity = 2 * min_capacity;
350 st->string = xrealloc (st->string, st->capacity + 1);
354 /* Shrink ST to the minimum capacity need to contain its content. */
356 ds_shrink (struct string *st)
358 if (st->capacity != st->length)
360 st->capacity = st->length;
361 st->string = xrealloc (st->string, st->capacity + 1);
365 /* Truncates ST to at most LENGTH characters long. */
367 ds_truncate (struct string *st, size_t length)
369 if (st->length > length)
373 /* Pad ST on the right with copies of PAD until ST is at least
374 LENGTH characters in size. If ST is initially LENGTH
375 characters or longer, this is a no-op. */
377 ds_rpad (struct string *st, size_t length, char pad)
379 if (length > st->length)
380 ds_putc_multiple (st, pad, length - st->length);
383 /* Removes trailing spaces from ST.
384 Returns number of spaces removed. */
386 ds_rtrim_spaces (struct string *st)
389 while (isspace (ds_last (st)))
397 /* Removes leading spaces from ST.
398 Returns number of spaces removed. */
400 ds_ltrim_spaces (struct string *st)
403 while (isspace (ds_at (st, cnt)))
406 ds_assign_substring (st, st, cnt, SIZE_MAX);
410 /* Trims leading and trailing spaces from ST. */
412 ds_trim_spaces (struct string *st)
414 ds_rtrim_spaces (st);
415 ds_ltrim_spaces (st);
418 /* If the last character in ST is C, removes it and returns true.
419 Otherwise, returns false without modifying ST. */
421 ds_chomp (struct string *st, char c_)
423 unsigned char c = c_;
424 if (ds_last (st) == c)
433 /* Divides ST into tokens separated by any of the DELIMITERS.
434 Each call replaces TOKEN by the next token in ST, or by an
435 empty string if no tokens remain. Returns true if a token was
436 obtained, false otherwise.
438 Before the first call, initialize *SAVE_IDX to 0. Do not
439 modify *SAVE_IDX between calls.
441 ST divides into exactly one more tokens than it contains
442 delimiters. That is, a delimiter at the start or end of ST or
443 a pair of adjacent delimiters yields an empty token, and the
444 empty string contains a single token. */
446 ds_separate (const struct string *st, struct string *token,
447 const char *delimiters, size_t *save_idx)
449 if (*save_idx <= ds_length (st))
451 size_t length = ds_cspan (st, *save_idx, delimiters);
452 ds_assign_substring (token, st, *save_idx, length);
453 *save_idx += length + 1;
460 /* Divides ST into tokens separated by any of the DELIMITERS,
461 merging adjacent delimiters so that the empty string is never
462 produced as a token. Each call replaces TOKEN by the next
463 token in ST, or by an empty string if no tokens remain.
464 Returns true if a token was obtained, false otherwise.
466 Before the first call, initialize *SAVE_IDX to 0. Do not
467 modify *SAVE_IDX between calls. */
469 ds_tokenize (const struct string *st, struct string *token,
470 const char *delimiters, size_t *save_idx)
472 size_t start = *save_idx + ds_span (st, *save_idx, delimiters);
473 size_t length = ds_cspan (st, start, delimiters);
474 ds_assign_substring (token, st, start, length);
475 *save_idx = start + length;
479 /* Returns true if ST is empty, false otherwise. */
481 ds_is_empty (const struct string *st)
483 return st->length == 0;
486 /* Returns the length of ST. */
488 ds_length (const struct string *st)
493 /* Returns the value of ST as a null-terminated string. */
495 ds_c_str (const struct string *st_)
497 struct string *st = (struct string *) st_;
498 if (st->string == NULL)
500 st->string[st->length] = '\0';
504 /* Returns the string data inside ST. */
506 ds_data (const struct string *st)
511 /* Returns a pointer to the null terminator ST.
512 This might not be an actual null character unless ds_c_str() has
513 been called since the last modification to ST. */
515 ds_end (const struct string *st)
517 return st->string + st->length;
520 /* Returns the allocation size of ST. */
522 ds_capacity (const struct string *st)
527 /* Returns the character in position IDX in ST, as a value in the
528 range of unsigned char. Returns EOF if IDX is out of the
529 range of indexes for ST. */
531 ds_at (const struct string *st, size_t idx)
533 return idx < st->length ? (unsigned char) st->string[idx] : EOF;
536 /* Returns the first character in ST as a value in the range of
537 unsigned char. Returns EOF if ST is the empty string. */
539 ds_first (const struct string *st)
541 return ds_at (st, 0);
544 /* Returns the last character in ST as a value in the range of
545 unsigned char. Returns EOF if ST is the empty string. */
547 ds_last (const struct string *st)
549 return st->length > 0 ? (unsigned char) st->string[st->length - 1] : EOF;
552 /* Returns the number of consecutive characters starting at OFS
553 in ST that are in SKIP_SET. (The null terminator is not
554 considered to be part of SKIP_SET.) */
556 ds_span (const struct string *st, size_t ofs, const char skip_set[])
559 for (i = ofs; i < st->length; i++)
561 int c = st->string[i];
562 if (strchr (skip_set, c) == NULL || c == '\0')
568 /* Returns the number of consecutive characters starting at OFS
569 in ST that are not in STOP_SET. (The null terminator is not
570 considered to be part of STOP_SET.) */
572 ds_cspan (const struct string *st, size_t ofs, const char stop_set[])
575 for (i = ofs; i < st->length; i++)
577 int c = st->string[i];
578 if (strchr (stop_set, c) != NULL)
584 /* Appends to ST a newline-terminated line read from STREAM.
585 Newline is the last character of ST on return, unless an I/O error
586 or end of file is encountered after reading some characters.
587 Returns true if a line is successfully read, false if no characters at
588 all were read before an I/O error or end of file was
591 ds_gets (struct string *st, FILE *stream)
611 /* Removes a comment introduced by `#' from ST,
612 ignoring occurrences inside quoted strings. */
614 remove_comment (struct string *st)
619 for (cp = ds_c_str (st); cp < ds_end (st); cp++)
624 else if (*cp == '\\')
627 else if (*cp == '\'' || *cp == '"')
631 ds_truncate (st, cp - ds_c_str (st));
636 /* Reads a line from STREAM into ST, then preprocesses as follows:
638 - Splices lines terminated with `\'.
640 - Deletes comments introduced by `#' outside of single or double
643 - Deletes trailing white space.
645 Returns true if a line was successfully read, false on
646 failure. If LINE_NUMBER is non-null, then *LINE_NUMBER is
647 incremented by the number of lines read. */
649 ds_get_config_line (FILE *stream, struct string *st, int *line_number)
654 if (!ds_gets (st, stream))
657 ds_rtrim_spaces (st);
659 while (ds_chomp (st, '\\'));
665 /* Concatenates S onto ST. */
667 ds_puts (struct string *st, const char *s)
674 ds_extend (st, st->length + s_len);
675 strcpy (st->string + st->length, s);
679 /* Concatenates LEN characters from BUF onto ST. */
681 ds_concat (struct string *st, const char *buf, size_t len)
683 ds_extend (st, st->length + len);
684 memcpy (st->string + st->length, buf, len);
688 /* Returns ds_end(ST) and THEN increases the length by INCR. */
690 ds_append_uninit(struct string *st, size_t incr)
694 ds_extend(st, ds_length(st) + incr);
703 /* Formats FORMAT as a printf string and appends the result to ST. */
705 ds_printf (struct string *st, const char *format, ...)
709 va_start (args, format);
710 ds_vprintf(st, format, args);
714 /* Formats FORMAT as a printf string and appends the result to ST. */
716 ds_vprintf (struct string *st, const char *format, va_list args_)
721 va_copy (args, args_);
722 avail = st->string != NULL ? st->capacity - st->length + 1 : 0;
723 needed = vsnprintf (st->string + st->length, avail, format, args);
728 ds_extend (st, st->length + needed);
730 va_copy (args, args_);
731 vsprintf (st->string + st->length, format, args);
736 /* Some old libc's returned -1 when the destination string
740 ds_extend (st, (st->capacity + 1) * 2);
741 avail = st->capacity - st->length + 1;
743 va_copy (args, args_);
744 needed = vsnprintf (st->string + st->length, avail, format, args);
749 st->length += needed;
752 /* Appends character CH to ST. */
754 ds_putc (struct string *st, int ch)
756 if (st->length >= st->capacity)
757 ds_extend (st, st->length + 1);
758 st->string[st->length++] = ch;
761 /* Appends CNT copies of character CH to ST. */
763 ds_putc_multiple (struct string *st, int ch, size_t cnt)
765 ds_extend (st, st->length + cnt);
766 memset (&st->string[st->length], ch, cnt);
771 /* Lengthed strings. */
773 /* Creates a new lengthed string LS with contents as a copy of
776 ls_create (struct fixed_string *ls, const char *s)
778 ls->length = strlen (s);
779 ls->string = xmalloc (ls->length + 1);
780 memcpy (ls->string, s, ls->length + 1);
783 /* Creates a new lengthed string LS with contents as a copy of
784 BUFFER with length LEN. */
786 ls_create_buffer (struct fixed_string *ls,
787 const char *buffer, size_t len)
790 ls->string = xmalloc (len + 1);
791 memcpy (ls->string, buffer, len);
792 ls->string[len] = '\0';
795 /* Sets the fields of LS to the specified values. */
797 ls_init (struct fixed_string *ls, const char *string, size_t length)
799 ls->string = (char *) string;
803 /* Copies the fields of SRC to DST. */
805 ls_shallow_copy (struct fixed_string *dst, const struct fixed_string *src)
810 /* Frees the memory backing LS. */
812 ls_destroy (struct fixed_string *ls)
817 /* Sets LS to a null pointer value. */
819 ls_null (struct fixed_string *ls)
824 /* Returns nonzero only if LS has a null pointer value. */
826 ls_null_p (const struct fixed_string *ls)
828 return ls->string == NULL;
831 /* Returns nonzero only if LS is a null pointer or has length 0. */
833 ls_empty_p (const struct fixed_string *ls)
835 return ls->string == NULL || ls->length == 0;
838 /* Returns the length of LS, which must not be null. */
840 ls_length (const struct fixed_string *ls)
845 /* Returns a pointer to the character string in LS. */
847 ls_c_str (const struct fixed_string *ls)
849 return (char *) ls->string;
852 /* Returns a pointer to the null terminator of the character string in
855 ls_end (const struct fixed_string *ls)
857 return (char *) (ls->string + ls->length);