1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006 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/>. */
26 #include <libpspp/message.h>
27 #include <libpspp/pool.h>
33 /* Reverses the order of NBYTES bytes at address P, thus converting
34 between little- and big-endian byte orders. */
36 buf_reverse (char *p, size_t nbytes)
38 char *h = p, *t = &h[nbytes - 1];
50 /* Finds the last NEEDLE of length NEEDLE_LEN in a HAYSTACK of length
51 HAYSTACK_LEN. Returns a pointer to the needle found. */
53 buf_find_reverse (const char *haystack, size_t haystack_len,
54 const char *needle, size_t needle_len)
57 for (i = haystack_len - needle_len; i >= 0; i--)
58 if (!memcmp (needle, &haystack[i], needle_len))
59 return (char *) &haystack[i];
63 /* Compares the SIZE bytes in A to those in B, disregarding case,
64 and returns a strcmp()-type result. */
66 buf_compare_case (const char *a_, const char *b_, size_t size)
68 const unsigned char *a = (unsigned char *) a_;
69 const unsigned char *b = (unsigned char *) b_;
73 unsigned char ac = toupper (*a++);
74 unsigned char bc = toupper (*b++);
77 return ac > bc ? 1 : -1;
83 /* Compares A of length A_LEN to B of length B_LEN. The shorter
84 string is considered to be padded with spaces to the length of
87 buf_compare_rpad (const char *a, size_t a_len, const char *b, size_t b_len)
92 min_len = a_len < b_len ? a_len : b_len;
93 result = memcmp (a, b, min_len);
102 for (idx = min_len; idx < b_len; idx++)
104 return ' ' > b[idx] ? 1 : -1;
108 for (idx = min_len; idx < a_len; idx++)
110 return a[idx] > ' ' ? 1 : -1;
116 /* Compares strin A to string B. The shorter string is
117 considered to be padded with spaces to the length of the
120 str_compare_rpad (const char *a, const char *b)
122 return buf_compare_rpad (a, strlen (a), b, strlen (b));
125 /* Copies string SRC to buffer DST, of size DST_SIZE bytes.
126 DST is truncated to DST_SIZE bytes or padded on the right with
129 buf_copy_str_rpad (char *dst, size_t dst_size, const char *src)
131 size_t src_len = strlen (src);
132 if (src_len >= dst_size)
133 memcpy (dst, src, dst_size);
136 memcpy (dst, src, src_len);
137 memset (&dst[src_len], ' ', dst_size - src_len);
141 /* Copies string SRC to buffer DST, of size DST_SIZE bytes.
142 DST is truncated to DST_SIZE bytes or padded on the left with
145 buf_copy_str_lpad (char *dst, size_t dst_size, const char *src)
147 size_t src_len = strlen (src);
148 if (src_len >= dst_size)
149 memcpy (dst, src, dst_size);
152 size_t pad_cnt = dst_size - src_len;
153 memset (&dst[0], ' ', pad_cnt);
154 memcpy (dst + pad_cnt, src, src_len);
158 /* Copies buffer SRC, of SRC_SIZE bytes, to DST, of DST_SIZE bytes.
159 DST is truncated to DST_SIZE bytes or padded on the left with
162 buf_copy_lpad (char *dst, size_t dst_size,
163 const char *src, size_t src_size)
165 if (src_size >= dst_size)
166 memmove (dst, src, dst_size);
169 memset (dst, ' ', dst_size - src_size);
170 memmove (&dst[dst_size - src_size], src, src_size);
174 /* Copies buffer SRC, of SRC_SIZE bytes, to DST, of DST_SIZE bytes.
175 DST is truncated to DST_SIZE bytes or padded on the right with
178 buf_copy_rpad (char *dst, size_t dst_size,
179 const char *src, size_t src_size)
181 if (src_size >= dst_size)
182 memmove (dst, src, dst_size);
185 memmove (dst, src, src_size);
186 memset (&dst[src_size], ' ', dst_size - src_size);
190 /* Copies string SRC to string DST, which is in a buffer DST_SIZE
192 Truncates DST to DST_SIZE - 1 characters or right-pads with
193 spaces to DST_SIZE - 1 characters if necessary. */
195 str_copy_rpad (char *dst, size_t dst_size, const char *src)
199 size_t src_len = strlen (src);
200 if (src_len < dst_size - 1)
202 memcpy (dst, src, src_len);
203 memset (&dst[src_len], ' ', dst_size - 1 - src_len);
206 memcpy (dst, src, dst_size - 1);
207 dst[dst_size - 1] = 0;
211 /* Copies SRC to DST, which is in a buffer DST_SIZE bytes long.
212 Truncates DST to DST_SIZE - 1 characters, if necessary. */
214 str_copy_trunc (char *dst, size_t dst_size, const char *src)
216 size_t src_len = strlen (src);
217 assert (dst_size > 0);
218 if (src_len + 1 < dst_size)
219 memcpy (dst, src, src_len + 1);
222 memcpy (dst, src, dst_size - 1);
223 dst[dst_size - 1] = '\0';
227 /* Copies buffer SRC, of SRC_LEN bytes,
228 to DST, which is in a buffer DST_SIZE bytes long.
229 Truncates DST to DST_SIZE - 1 characters, if necessary. */
231 str_copy_buf_trunc (char *dst, size_t dst_size,
232 const char *src, size_t src_size)
235 assert (dst_size > 0);
237 dst_len = src_size < dst_size ? src_size : dst_size - 1;
238 memcpy (dst, src, dst_len);
242 /* Converts each character in S to uppercase. */
244 str_uppercase (char *s)
246 for (; *s != '\0'; s++)
247 *s = toupper ((unsigned char) *s);
250 /* Converts each character in S to lowercase. */
252 str_lowercase (char *s)
254 for (; *s != '\0'; s++)
255 *s = tolower ((unsigned char) *s);
258 /* Converts NUMBER into a string in 26-adic notation in BUFFER,
259 which has room for SIZE bytes. Returns true if successful,
260 false if NUMBER, plus a trailing null, is too large to fit in
263 26-adic notation is "spreadsheet column numbering": 1 = A, 2 =
264 B, 3 = C, ... 26 = Z, 27 = AA, 28 = AB, 29 = AC, ...
266 26-adic notation is the special case of a k-adic numeration
267 system (aka bijective base-k numeration) with k=26. In k-adic
268 numeration, the digits are {1, 2, 3, ..., k} (there is no
269 digit 0), and integer 0 is represented by the empty string.
270 For more information, see
271 http://en.wikipedia.org/wiki/Bijective_numeration. */
273 str_format_26adic (unsigned long int number, char buffer[], size_t size)
281 buffer[length++] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[number % 26];
287 buffer[length] = '\0';
289 buf_reverse (buffer, length);
293 /* Formats FORMAT into DST, as with sprintf(), and returns the
294 address of the terminating null written to DST. */
296 spprintf (char *dst, const char *format, ...)
301 va_start (args, format);
302 count = vsprintf (dst, format, args);
308 /* Sets the SIZE bytes starting at BLOCK to C,
309 and returns the byte following BLOCK. */
311 mempset (void *block, int c, size_t size)
313 memset (block, c, size);
314 return (char *) block + size;
319 /* Returns an empty substring. */
329 /* Returns a substring whose contents are the given C-style
332 ss_cstr (const char *cstr)
334 return ss_buffer (cstr, strlen (cstr));
337 /* Returns a substring whose contents are the CNT characters in
340 ss_buffer (const char *buffer, size_t cnt)
343 ss.string = (char *) buffer;
348 /* Returns a substring whose contents are the CNT characters
349 starting at the (0-based) position START in SS. */
351 ss_substr (struct substring ss, size_t start, size_t cnt)
353 if (start < ss.length)
354 return ss_buffer (ss.string + start, MIN (cnt, ss.length - start));
356 return ss_buffer (ss.string + ss.length, 0);
359 /* Returns a substring whose contents are the first CNT
362 ss_head (struct substring ss, size_t cnt)
364 return ss_buffer (ss.string, MIN (cnt, ss.length));
367 /* Returns a substring whose contents are the last CNT characters
370 ss_tail (struct substring ss, size_t cnt)
373 return ss_buffer (ss.string + (ss.length - cnt), cnt);
378 /* Makes a malloc()'d copy of the contents of OLD
379 and stores it in NEW. */
381 ss_alloc_substring (struct substring *new, struct substring old)
383 new->string = xmalloc (old.length);
384 new->length = old.length;
385 memcpy (new->string, old.string, old.length);
388 /* Allocates room for a CNT-character string in NEW. */
390 ss_alloc_uninit (struct substring *new, size_t cnt)
392 new->string = xmalloc (cnt);
396 /* Makes a pool_alloc_unaligned()'d copy of the contents of OLD
397 in POOL, and stores it in NEW. */
399 ss_alloc_substring_pool (struct substring *new, struct substring old,
402 new->string = pool_alloc_unaligned (pool, old.length);
403 new->length = old.length;
404 memcpy (new->string, old.string, old.length);
407 /* Allocates room for a CNT-character string in NEW in POOL. */
409 ss_alloc_uninit_pool (struct substring *new, size_t cnt, struct pool *pool)
411 new->string = pool_alloc_unaligned (pool, cnt);
415 /* Frees the string that SS points to. */
417 ss_dealloc (struct substring *ss)
422 /* Truncates SS to at most CNT characters in length. */
424 ss_truncate (struct substring *ss, size_t cnt)
426 if (ss->length > cnt)
430 /* Removes trailing characters in TRIM_SET from SS.
431 Returns number of characters removed. */
433 ss_rtrim (struct substring *ss, struct substring trim_set)
436 while (cnt < ss->length
437 && ss_find_char (trim_set,
438 ss->string[ss->length - cnt - 1]) != SIZE_MAX)
444 /* Removes leading characters in TRIM_SET from SS.
445 Returns number of characters removed. */
447 ss_ltrim (struct substring *ss, struct substring trim_set)
449 size_t cnt = ss_span (*ss, trim_set);
450 ss_advance (ss, cnt);
454 /* Trims leading and trailing characters in TRIM_SET from SS. */
456 ss_trim (struct substring *ss, struct substring trim_set)
458 ss_ltrim (ss, trim_set);
459 ss_rtrim (ss, trim_set);
462 /* If the last character in SS is C, removes it and returns true.
463 Otherwise, returns false without changing the string. */
465 ss_chomp (struct substring *ss, char c)
467 if (ss_last (*ss) == c)
476 /* Divides SS into tokens separated by any of the DELIMITERS.
477 Each call replaces TOKEN by the next token in SS, or by an
478 empty string if no tokens remain. Returns true if a token was
479 obtained, false otherwise.
481 Before the first call, initialize *SAVE_IDX to 0. Do not
482 modify *SAVE_IDX between calls.
484 SS divides into exactly one more tokens than it contains
485 delimiters. That is, a delimiter at the start or end of SS or
486 a pair of adjacent delimiters yields an empty token, and the
487 empty string contains a single token. */
489 ss_separate (struct substring ss, struct substring delimiters,
490 size_t *save_idx, struct substring *token)
492 if (*save_idx <= ss_length (ss))
494 struct substring tmp = ss_substr (ss, *save_idx, SIZE_MAX);
495 size_t length = ss_cspan (tmp, delimiters);
496 *token = ss_head (tmp, length);
497 *save_idx += length + 1;
502 *token = ss_empty ();
507 /* Divides SS into tokens separated by any of the DELIMITERS,
508 merging adjacent delimiters so that the empty string is never
509 produced as a token. Each call replaces TOKEN by the next
510 token in SS, or by an empty string if no tokens remain, and
511 then skips past the first delimiter following the token.
512 Returns true if a token was obtained, false otherwise.
514 Before the first call, initialize *SAVE_IDX to 0. Do not
515 modify *SAVE_IDX between calls. */
517 ss_tokenize (struct substring ss, struct substring delimiters,
518 size_t *save_idx, struct substring *token)
520 ss_advance (&ss, *save_idx);
521 *save_idx += ss_ltrim (&ss, delimiters);
522 ss_get_chars (&ss, ss_cspan (ss, delimiters), token);
523 *save_idx += ss_length (*token) + 1;
524 return ss_length (*token) > 0;
527 /* Removes the first CNT characters from SS. */
529 ss_advance (struct substring *ss, size_t cnt)
531 if (cnt > ss->length)
537 /* If the first character in SS is C, removes it and returns true.
538 Otherwise, returns false without changing the string. */
540 ss_match_char (struct substring *ss, char c)
542 if (ss_first (*ss) == c)
552 /* If the first character in SS is in MATCH, removes it and
553 returns the character that was removed.
554 Otherwise, returns EOF without changing the string. */
556 ss_match_char_in (struct substring *ss, struct substring match)
560 && memchr (match.string, ss->string[0], match.length) != NULL)
569 /* If SS begins with TARGET, removes it and returns true.
570 Otherwise, returns false without changing SS. */
572 ss_match_string (struct substring *ss, const struct substring target)
574 size_t length = ss_length (target);
575 if (ss_equals (ss_head (*ss, length), target))
577 ss_advance (ss, length);
584 /* Removes the first character from SS and returns it.
585 If SS is empty, returns EOF without modifying SS. */
587 ss_get_char (struct substring *ss)
589 int c = ss_first (*ss);
598 /* Stores the prefix of SS up to the first DELIMITER in OUT (if
599 any). Trims those same characters from SS. DELIMITER is
600 removed from SS but not made part of OUT. Returns true if
601 DELIMITER was found (and removed), false otherwise. */
603 ss_get_until (struct substring *ss, char delimiter, struct substring *out)
605 ss_get_chars (ss, ss_cspan (*ss, ss_buffer (&delimiter, 1)), out);
606 return ss_match_char (ss, delimiter);
609 /* Stores the first CNT characters in SS in OUT (or fewer, if SS
610 is shorter than CNT characters). Trims the same characters
611 from the beginning of SS. Returns CNT. */
613 ss_get_chars (struct substring *ss, size_t cnt, struct substring *out)
615 *out = ss_head (*ss, cnt);
616 ss_advance (ss, cnt);
620 /* Parses and removes an optionally signed decimal integer from
621 the beginning of SS. Returns 0 if an error occurred,
622 otherwise the number of characters removed from SS. Stores
623 the integer's value into *VALUE. */
625 ss_get_long (struct substring *ss, long *value)
630 length = ss_span (*ss, ss_cstr ("+-"));
631 length += ss_span (ss_substr (*ss, length, SIZE_MAX), ss_cstr (CC_DIGITS));
632 if (length > 0 && length < sizeof tmp)
636 memcpy (tmp, ss_data (*ss), length);
639 *value = strtol (tmp, &tail, 10);
640 if (tail - tmp == length)
642 ss_advance (ss, length);
650 /* Returns true if SS is empty (contains no characters),
653 ss_is_empty (struct substring ss)
655 return ss.length == 0;
658 /* Returns the number of characters in SS. */
660 ss_length (struct substring ss)
665 /* Returns a pointer to the characters in SS. */
667 ss_data (struct substring ss)
672 /* Returns a pointer just past the last character in SS. */
674 ss_end (struct substring ss)
676 return ss.string + ss.length;
679 /* Returns the character in position IDX in SS, as a value in the
680 range of unsigned char. Returns EOF if IDX is out of the
681 range of indexes for SS. */
683 ss_at (struct substring ss, size_t idx)
685 return idx < ss.length ? (unsigned char) ss.string[idx] : EOF;
688 /* Returns the first character in SS as a value in the range of
689 unsigned char. Returns EOF if SS is the empty string. */
691 ss_first (struct substring ss)
693 return ss_at (ss, 0);
696 /* Returns the last character in SS as a value in the range of
697 unsigned char. Returns EOF if SS is the empty string. */
699 ss_last (struct substring ss)
701 return ss.length > 0 ? (unsigned char) ss.string[ss.length - 1] : EOF;
704 /* Returns the number of contiguous characters at the beginning
705 of SS that are in SKIP_SET. */
707 ss_span (struct substring ss, struct substring skip_set)
710 for (i = 0; i < ss.length; i++)
711 if (ss_find_char (skip_set, ss.string[i]) == SIZE_MAX)
716 /* Returns the number of contiguous characters at the beginning
717 of SS that are not in SKIP_SET. */
719 ss_cspan (struct substring ss, struct substring stop_set)
722 for (i = 0; i < ss.length; i++)
723 if (ss_find_char (stop_set, ss.string[i]) != SIZE_MAX)
728 /* Returns the offset in SS of the first instance of C,
729 or SIZE_MAX if C does not occur in SS. */
731 ss_find_char (struct substring ss, char c)
733 const char *p = memchr (ss.string, c, ss.length);
734 return p != NULL ? p - ss.string : SIZE_MAX;
737 /* Compares A and B and returns a strcmp()-type comparison
740 ss_compare (struct substring a, struct substring b)
742 int retval = memcmp (a.string, b.string, MIN (a.length, b.length));
744 retval = a.length < b.length ? -1 : a.length > b.length;
748 /* Compares A and B case-insensitively and returns a
749 strcmp()-type comparison result. */
751 ss_compare_case (struct substring a, struct substring b)
753 int retval = memcasecmp (a.string, b.string, MIN (a.length, b.length));
755 retval = a.length < b.length ? -1 : a.length > b.length;
759 /* Compares A and B and returns true if their contents are
760 identical, false otherwise. */
762 ss_equals (struct substring a, struct substring b)
764 return a.length == b.length && !memcmp (a.string, b.string, a.length);
767 /* Compares A and B and returns true if their contents are
768 identical except possibly for case differences, false
771 ss_equals_case (struct substring a, struct substring b)
773 return a.length == b.length && !memcasecmp (a.string, b.string, a.length);
776 /* Returns the position in SS that the character at P occupies.
777 P must point within SS or one past its end. */
779 ss_pointer_to_position (struct substring ss, const char *p)
781 size_t pos = p - ss.string;
782 assert (pos <= ss.length);
786 /* Allocates and returns a null-terminated string that contains
789 ss_xstrdup (struct substring ss)
791 char *s = xmalloc (ss.length + 1);
792 memcpy (s, ss.string, ss.length);
797 /* Initializes ST as an empty string. */
799 ds_init_empty (struct string *st)
801 st->ss = ss_empty ();
805 /* Initializes ST with initial contents S. */
807 ds_init_string (struct string *st, const struct string *s)
809 ds_init_substring (st, ds_ss (s));
812 /* Initializes ST with initial contents SS. */
814 ds_init_substring (struct string *st, struct substring ss)
816 st->capacity = MAX (8, ss.length * 2);
817 st->ss.string = xmalloc (st->capacity + 1);
818 memcpy (st->ss.string, ss.string, ss.length);
819 st->ss.length = ss.length;
822 /* Initializes ST with initial contents S. */
824 ds_init_cstr (struct string *st, const char *s)
826 ds_init_substring (st, ss_cstr (s));
831 ds_destroy (struct string *st)
835 ss_dealloc (&st->ss);
836 st->ss.string = NULL;
842 /* Swaps the contents of strings A and B. */
844 ds_swap (struct string *a, struct string *b)
846 struct string tmp = *a;
851 /* Helper function for ds_register_pool. */
853 free_string (void *st_)
855 struct string *st = st_;
859 /* Arranges for ST to be destroyed automatically as part of
862 ds_register_pool (struct string *st, struct pool *pool)
864 pool_register (pool, free_string, st);
867 /* Cancels the arrangement for ST to be destroyed automatically
870 ds_unregister_pool (struct string *st, struct pool *pool)
872 pool_unregister (pool, st);
875 /* Copies SRC into DST.
876 DST and SRC may be the same string. */
878 ds_assign_string (struct string *dst, const struct string *src)
880 ds_assign_substring (dst, ds_ss (src));
883 /* Replaces DST by SS.
884 SS may be a substring of DST. */
886 ds_assign_substring (struct string *dst, struct substring ss)
888 dst->ss.length = ss.length;
889 ds_extend (dst, ss.length);
890 memmove (dst->ss.string, ss.string, ss.length);
893 /* Replaces DST by null-terminated string SRC. SRC may overlap
896 ds_assign_cstr (struct string *dst, const char *src)
898 ds_assign_substring (dst, ss_cstr (src));
901 /* Truncates ST to zero length. */
903 ds_clear (struct string *st)
908 /* Returns a substring that contains ST. */
910 ds_ss (const struct string *st)
915 /* Returns a substring that contains CNT characters from ST
916 starting at position START.
918 If START is greater than or equal to the length of ST, then
919 the substring will be the empty string. If START + CNT
920 exceeds the length of ST, then the substring will only be
921 ds_length(ST) - START characters long. */
923 ds_substr (const struct string *st, size_t start, size_t cnt)
925 return ss_substr (ds_ss (st), start, cnt);
928 /* Returns a substring that contains the first CNT characters in
929 ST. If CNT exceeds the length of ST, then the substring will
930 contain all of ST. */
932 ds_head (const struct string *st, size_t cnt)
934 return ss_head (ds_ss (st), cnt);
937 /* Returns a substring that contains the last CNT characters in
938 ST. If CNT exceeds the length of ST, then the substring will
939 contain all of ST. */
941 ds_tail (const struct string *st, size_t cnt)
943 return ss_tail (ds_ss (st), cnt);
946 /* Ensures that ST can hold at least MIN_CAPACITY characters plus a null
949 ds_extend (struct string *st, size_t min_capacity)
951 if (min_capacity > st->capacity)
954 if (st->capacity < min_capacity)
955 st->capacity = 2 * min_capacity;
957 st->ss.string = xrealloc (st->ss.string, st->capacity + 1);
961 /* Shrink ST to the minimum capacity need to contain its content. */
963 ds_shrink (struct string *st)
965 if (st->capacity != st->ss.length)
967 st->capacity = st->ss.length;
968 st->ss.string = xrealloc (st->ss.string, st->capacity + 1);
972 /* Truncates ST to at most LENGTH characters long. */
974 ds_truncate (struct string *st, size_t length)
976 ss_truncate (&st->ss, length);
979 /* Removes trailing characters in TRIM_SET from ST.
980 Returns number of characters removed. */
982 ds_rtrim (struct string *st, struct substring trim_set)
984 return ss_rtrim (&st->ss, trim_set);
987 /* Removes leading characters in TRIM_SET from ST.
988 Returns number of characters removed. */
990 ds_ltrim (struct string *st, struct substring trim_set)
992 size_t cnt = ds_span (st, trim_set);
994 ds_assign_substring (st, ds_substr (st, cnt, SIZE_MAX));
998 /* Trims leading and trailing characters in TRIM_SET from ST.
999 Returns number of charactesr removed. */
1001 ds_trim (struct string *st, struct substring trim_set)
1003 size_t cnt = ds_rtrim (st, trim_set);
1004 return cnt + ds_ltrim (st, trim_set);
1007 /* If the last character in ST is C, removes it and returns true.
1008 Otherwise, returns false without modifying ST. */
1010 ds_chomp (struct string *st, char c)
1012 return ss_chomp (&st->ss, c);
1015 /* Divides ST into tokens separated by any of the DELIMITERS.
1016 Each call replaces TOKEN by the next token in ST, or by an
1017 empty string if no tokens remain. Returns true if a token was
1018 obtained, false otherwise.
1020 Before the first call, initialize *SAVE_IDX to 0. Do not
1021 modify *SAVE_IDX between calls.
1023 ST divides into exactly one more tokens than it contains
1024 delimiters. That is, a delimiter at the start or end of ST or
1025 a pair of adjacent delimiters yields an empty token, and the
1026 empty string contains a single token. */
1028 ds_separate (const struct string *st, struct substring delimiters,
1029 size_t *save_idx, struct substring *token)
1031 return ss_separate (ds_ss (st), delimiters, save_idx, token);
1034 /* Divides ST into tokens separated by any of the DELIMITERS,
1035 merging adjacent delimiters so that the empty string is never
1036 produced as a token. Each call replaces TOKEN by the next
1037 token in ST, or by an empty string if no tokens remain.
1038 Returns true if a token was obtained, false otherwise.
1040 Before the first call, initialize *SAVE_IDX to 0. Do not
1041 modify *SAVE_IDX between calls. */
1043 ds_tokenize (const struct string *st, struct substring delimiters,
1044 size_t *save_idx, struct substring *token)
1046 return ss_tokenize (ds_ss (st), delimiters, save_idx, token);
1049 /* Pad ST on the right with copies of PAD until ST is at least
1050 LENGTH characters in size. If ST is initially LENGTH
1051 characters or longer, this is a no-op. */
1053 ds_rpad (struct string *st, size_t length, char pad)
1055 if (length > st->ss.length)
1056 ds_put_char_multiple (st, pad, length - st->ss.length);
1059 /* Sets the length of ST to exactly NEW_LENGTH,
1060 either by truncating characters from the end,
1061 or by padding on the right with PAD. */
1063 ds_set_length (struct string *st, size_t new_length, char pad)
1065 if (st->ss.length < new_length)
1066 ds_rpad (st, new_length, pad);
1068 st->ss.length = new_length;
1071 /* Returns true if ST is empty, false otherwise. */
1073 ds_is_empty (const struct string *st)
1075 return ss_is_empty (st->ss);
1078 /* Returns the length of ST. */
1080 ds_length (const struct string *st)
1082 return ss_length (ds_ss (st));
1085 /* Returns the string data inside ST. */
1087 ds_data (const struct string *st)
1089 return ss_data (ds_ss (st));
1092 /* Returns a pointer to the null terminator ST.
1093 This might not be an actual null character unless ds_c_str() has
1094 been called since the last modification to ST. */
1096 ds_end (const struct string *st)
1098 return ss_end (ds_ss (st));
1101 /* Returns the character in position IDX in ST, as a value in the
1102 range of unsigned char. Returns EOF if IDX is out of the
1103 range of indexes for ST. */
1105 ds_at (const struct string *st, size_t idx)
1107 return ss_at (ds_ss (st), idx);
1110 /* Returns the first character in ST as a value in the range of
1111 unsigned char. Returns EOF if ST is the empty string. */
1113 ds_first (const struct string *st)
1115 return ss_first (ds_ss (st));
1118 /* Returns the last character in ST as a value in the range of
1119 unsigned char. Returns EOF if ST is the empty string. */
1121 ds_last (const struct string *st)
1123 return ss_last (ds_ss (st));
1126 /* Returns the number of consecutive characters at the beginning
1127 of ST that are in SKIP_SET. */
1129 ds_span (const struct string *st, struct substring skip_set)
1131 return ss_span (ds_ss (st), skip_set);
1134 /* Returns the number of consecutive characters at the beginning
1135 of ST that are not in STOP_SET. */
1137 ds_cspan (const struct string *st, struct substring stop_set)
1139 return ss_cspan (ds_ss (st), stop_set);
1142 /* Returns the position of the first occurrence of character C in
1143 ST at or after position OFS, or SIZE_MAX if there is no such
1146 ds_find_char (const struct string *st, char c)
1148 return ss_find_char (ds_ss (st), c);
1151 /* Compares A and B and returns a strcmp()-type comparison
1154 ds_compare (const struct string *a, const struct string *b)
1156 return ss_compare (ds_ss (a), ds_ss (b));
1159 /* Returns the position in ST that the character at P occupies.
1160 P must point within ST or one past its end. */
1162 ds_pointer_to_position (const struct string *st, const char *p)
1164 return ss_pointer_to_position (ds_ss (st), p);
1167 /* Allocates and returns a null-terminated string that contains
1170 ds_xstrdup (const struct string *st)
1172 return ss_xstrdup (ds_ss (st));
1175 /* Returns the allocation size of ST. */
1177 ds_capacity (const struct string *st)
1179 return st->capacity;
1182 /* Returns the value of ST as a null-terminated string. */
1184 ds_cstr (const struct string *st_)
1186 struct string *st = (struct string *) st_;
1187 if (st->ss.string == NULL)
1189 st->ss.string[st->ss.length] = '\0';
1190 return st->ss.string;
1193 /* Appends to ST a newline-terminated line read from STREAM, but
1194 no more than MAX_LENGTH characters.
1195 Newline is the last character of ST on return, if encountering
1196 a newline was the reason for terminating.
1197 Returns true if at least one character was read from STREAM
1198 and appended to ST, false if no characters at all were read
1199 before an I/O error or end of file was encountered (or
1200 MAX_LENGTH was 0). */
1202 ds_read_line (struct string *st, FILE *stream, size_t max_length)
1204 if (!st->ss.length && max_length == SIZE_MAX)
1206 size_t capacity = st->capacity ? st->capacity + 1 : 0;
1207 ssize_t n = getline (&st->ss.string, &capacity, stream);
1209 st->capacity = capacity - 1;
1222 for (length = 0; length < max_length; length++)
1224 int c = getc (stream);
1228 ds_put_char (st, c);
1237 /* Removes a comment introduced by `#' from ST,
1238 ignoring occurrences inside quoted strings. */
1240 remove_comment (struct string *st)
1245 for (cp = ds_data (st); cp < ds_end (st); cp++)
1250 else if (*cp == '\\')
1253 else if (*cp == '\'' || *cp == '"')
1255 else if (*cp == '#')
1257 ds_truncate (st, cp - ds_cstr (st));
1262 /* Reads a line from STREAM into ST, then preprocesses as follows:
1264 - Splices lines terminated with `\'.
1266 - Deletes comments introduced by `#' outside of single or double
1269 - Deletes trailing white space.
1271 Returns true if a line was successfully read, false on
1272 failure. If LINE_NUMBER is non-null, then *LINE_NUMBER is
1273 incremented by the number of lines read. */
1275 ds_read_config_line (struct string *st, int *line_number, FILE *stream)
1280 if (!ds_read_line (st, stream, SIZE_MAX))
1283 ds_rtrim (st, ss_cstr (CC_SPACES));
1285 while (ds_chomp (st, '\\'));
1287 remove_comment (st);
1291 /* Attempts to read SIZE * CNT bytes from STREAM and append them
1293 Returns true if all the requested data was read, false otherwise. */
1295 ds_read_stream (struct string *st, size_t size, size_t cnt, FILE *stream)
1299 size_t try_bytes = xtimes (cnt, size);
1300 if (size_in_bounds_p (xsum (ds_length (st), try_bytes)))
1302 char *buffer = ds_put_uninit (st, try_bytes);
1303 size_t got_bytes = fread (buffer, 1, try_bytes, stream);
1304 ds_truncate (st, ds_length (st) - (try_bytes - got_bytes));
1305 return got_bytes == try_bytes;
1317 /* Concatenates S onto ST. */
1319 ds_put_cstr (struct string *st, const char *s)
1322 ds_put_substring (st, ss_cstr (s));
1325 /* Concatenates SS to ST. */
1327 ds_put_substring (struct string *st, struct substring ss)
1329 memcpy (ds_put_uninit (st, ss_length (ss)), ss_data (ss), ss_length (ss));
1332 /* Returns ds_end(ST) and THEN increases the length by INCR. */
1334 ds_put_uninit (struct string *st, size_t incr)
1337 ds_extend (st, ds_length (st) + incr);
1339 st->ss.length += incr;
1343 /* Formats FORMAT as a printf string and appends the result to ST. */
1345 ds_put_format (struct string *st, const char *format, ...)
1349 va_start (args, format);
1350 ds_put_vformat (st, format, args);
1354 /* Formats FORMAT as a printf string and appends the result to ST. */
1356 ds_put_vformat (struct string *st, const char *format, va_list args_)
1361 va_copy (args, args_);
1362 avail = st->ss.string != NULL ? st->capacity - st->ss.length + 1 : 0;
1363 needed = vsnprintf (st->ss.string + st->ss.length, avail, format, args);
1366 if (needed >= avail)
1368 va_copy (args, args_);
1369 vsprintf (ds_put_uninit (st, needed), format, args);
1374 /* Some old libc's returned -1 when the destination string
1376 while (needed == -1)
1378 ds_extend (st, (st->capacity + 1) * 2);
1379 avail = st->capacity - st->ss.length + 1;
1381 va_copy (args, args_);
1382 needed = vsnprintf (ds_end (st), avail, format, args);
1385 st->ss.length += needed;
1389 /* Appends character CH to ST. */
1391 ds_put_char (struct string *st, int ch)
1393 ds_put_uninit (st, 1)[0] = ch;
1396 /* Appends CNT copies of character CH to ST. */
1398 ds_put_char_multiple (struct string *st, int ch, size_t cnt)
1400 memset (ds_put_uninit (st, cnt), ch, cnt);