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>
29 #include <relocatable.h>
34 /* Reverses the order of NBYTES bytes at address P, thus converting
35 between little- and big-endian byte orders. */
37 buf_reverse (char *p, size_t nbytes)
39 char *h = p, *t = &h[nbytes - 1];
51 /* Finds the last NEEDLE of length NEEDLE_LEN in a HAYSTACK of length
52 HAYSTACK_LEN. Returns a pointer to the needle found. */
54 buf_find_reverse (const char *haystack, size_t haystack_len,
55 const char *needle, size_t needle_len)
58 for (i = haystack_len - needle_len; i >= 0; i--)
59 if (!memcmp (needle, &haystack[i], needle_len))
60 return (char *) &haystack[i];
64 /* Compares the SIZE bytes in A to those in B, disregarding case,
65 and returns a strcmp()-type result. */
67 buf_compare_case (const char *a_, const char *b_, size_t size)
69 const unsigned char *a = (unsigned char *) a_;
70 const unsigned char *b = (unsigned char *) b_;
74 unsigned char ac = toupper (*a++);
75 unsigned char bc = toupper (*b++);
78 return ac > bc ? 1 : -1;
84 /* Compares A of length A_LEN to B of length B_LEN. The shorter
85 string is considered to be padded with spaces to the length of
88 buf_compare_rpad (const char *a, size_t a_len, const char *b, size_t b_len)
93 min_len = a_len < b_len ? a_len : b_len;
94 result = memcmp (a, b, min_len);
103 for (idx = min_len; idx < b_len; idx++)
105 return ' ' > b[idx] ? 1 : -1;
109 for (idx = min_len; idx < a_len; idx++)
111 return a[idx] > ' ' ? 1 : -1;
117 /* Compares strin A to string B. The shorter string is
118 considered to be padded with spaces to the length of the
121 str_compare_rpad (const char *a, const char *b)
123 return buf_compare_rpad (a, strlen (a), b, strlen (b));
126 /* Copies string SRC to buffer DST, of size DST_SIZE bytes.
127 DST is truncated to DST_SIZE bytes or padded on the right with
130 buf_copy_str_rpad (char *dst, size_t dst_size, const char *src)
132 size_t src_len = strlen (src);
133 if (src_len >= dst_size)
134 memcpy (dst, src, dst_size);
137 memcpy (dst, src, src_len);
138 memset (&dst[src_len], ' ', dst_size - src_len);
142 /* Copies string SRC to buffer DST, of size DST_SIZE bytes.
143 DST is truncated to DST_SIZE bytes or padded on the left with
146 buf_copy_str_lpad (char *dst, size_t dst_size, const char *src)
148 size_t src_len = strlen (src);
149 if (src_len >= dst_size)
150 memcpy (dst, src, dst_size);
153 size_t pad_cnt = dst_size - src_len;
154 memset (&dst[0], ' ', pad_cnt);
155 memcpy (dst + pad_cnt, src, src_len);
159 /* Copies buffer SRC, of SRC_SIZE bytes, to DST, of DST_SIZE bytes.
160 DST is truncated to DST_SIZE bytes or padded on the left with
163 buf_copy_lpad (char *dst, size_t dst_size,
164 const char *src, size_t src_size)
166 if (src_size >= dst_size)
167 memmove (dst, src, dst_size);
170 memset (dst, ' ', dst_size - src_size);
171 memmove (&dst[dst_size - src_size], src, src_size);
175 /* Copies buffer SRC, of SRC_SIZE bytes, to DST, of DST_SIZE bytes.
176 DST is truncated to DST_SIZE bytes or padded on the right with
179 buf_copy_rpad (char *dst, size_t dst_size,
180 const char *src, size_t src_size)
182 if (src_size >= dst_size)
183 memmove (dst, src, dst_size);
186 memmove (dst, src, src_size);
187 memset (&dst[src_size], ' ', dst_size - src_size);
191 /* Copies string SRC to string DST, which is in a buffer DST_SIZE
193 Truncates DST to DST_SIZE - 1 characters or right-pads with
194 spaces to DST_SIZE - 1 characters if necessary. */
196 str_copy_rpad (char *dst, size_t dst_size, const char *src)
198 size_t src_len = strlen (src);
199 if (src_len < dst_size - 1)
201 memcpy (dst, src, src_len);
202 memset (&dst[src_len], ' ', dst_size - 1 - src_len);
205 memcpy (dst, src, dst_size - 1);
206 dst[dst_size - 1] = 0;
209 /* Copies SRC to DST, which is in a buffer DST_SIZE bytes long.
210 Truncates DST to DST_SIZE - 1 characters, if necessary. */
212 str_copy_trunc (char *dst, size_t dst_size, const char *src)
214 size_t src_len = strlen (src);
215 assert (dst_size > 0);
216 if (src_len + 1 < dst_size)
217 memcpy (dst, src, src_len + 1);
220 memcpy (dst, src, dst_size - 1);
221 dst[dst_size - 1] = '\0';
225 /* Copies buffer SRC, of SRC_LEN bytes,
226 to DST, which is in a buffer DST_SIZE bytes long.
227 Truncates DST to DST_SIZE - 1 characters, if necessary. */
229 str_copy_buf_trunc (char *dst, size_t dst_size,
230 const char *src, size_t src_size)
233 assert (dst_size > 0);
235 dst_len = src_size < dst_size ? src_size : dst_size - 1;
236 memcpy (dst, src, dst_len);
240 /* Converts each character in S to uppercase. */
242 str_uppercase (char *s)
244 for (; *s != '\0'; s++)
245 *s = toupper ((unsigned char) *s);
248 /* Converts each character in S to lowercase. */
250 str_lowercase (char *s)
252 for (; *s != '\0'; s++)
253 *s = tolower ((unsigned char) *s);
256 /* Converts NUMBER into a string in 26-adic notation in BUFFER,
257 which has room for SIZE bytes. Returns true if successful,
258 false if NUMBER, plus a trailing null, is too large to fit in
261 26-adic notation is "spreadsheet column numbering": 1 = A, 2 =
262 B, 3 = C, ... 26 = Z, 27 = AA, 28 = AB, 29 = AC, ...
264 26-adic notation is the special case of a k-adic numeration
265 system (aka bijective base-k numeration) with k=26. In k-adic
266 numeration, the digits are {1, 2, 3, ..., k} (there is no
267 digit 0), and integer 0 is represented by the empty string.
268 For more information, see
269 http://en.wikipedia.org/wiki/Bijective_numeration. */
271 str_format_26adic (unsigned long int number, char buffer[], size_t size)
279 buffer[length++] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[number % 26];
285 buffer[length] = '\0';
287 buf_reverse (buffer, length);
291 /* Formats FORMAT into DST, as with sprintf(), and returns the
292 address of the terminating null written to DST. */
294 spprintf (char *dst, const char *format, ...)
299 va_start (args, format);
300 count = vsprintf (dst, format, args);
306 /* Sets the SIZE bytes starting at BLOCK to C,
307 and returns the byte following BLOCK. */
309 mempset (void *block, int c, size_t size)
311 memset (block, c, size);
312 return (char *) block + size;
317 /* Returns an empty substring. */
327 /* Returns a substring whose contents are the given C-style
330 ss_cstr (const char *cstr)
332 return ss_buffer (cstr, strlen (cstr));
335 /* Returns a substring whose contents are the CNT characters in
338 ss_buffer (const char *buffer, size_t cnt)
341 ss.string = (char *) buffer;
346 /* Returns a substring whose contents are the CNT characters
347 starting at the (0-based) position START in SS. */
349 ss_substr (struct substring ss, size_t start, size_t cnt)
351 if (start < ss.length)
352 return ss_buffer (ss.string + start, MIN (cnt, ss.length - start));
354 return ss_buffer (ss.string + ss.length, 0);
357 /* Returns a substring whose contents are the first CNT
360 ss_head (struct substring ss, size_t cnt)
362 return ss_buffer (ss.string, MIN (cnt, ss.length));
365 /* Returns a substring whose contents are the last CNT characters
368 ss_tail (struct substring ss, size_t cnt)
371 return ss_buffer (ss.string + (ss.length - cnt), cnt);
376 /* Makes a malloc()'d copy of the contents of OLD
377 and stores it in NEW. */
379 ss_alloc_substring (struct substring *new, struct substring old)
381 new->string = xmalloc (old.length);
382 new->length = old.length;
383 memcpy (new->string, old.string, old.length);
386 /* Allocates room for a CNT-character string in NEW. */
388 ss_alloc_uninit (struct substring *new, size_t cnt)
390 new->string = xmalloc (cnt);
394 /* Makes a pool_alloc_unaligned()'d copy of the contents of OLD
395 in POOL, and stores it in NEW. */
397 ss_alloc_substring_pool (struct substring *new, struct substring old,
400 new->string = pool_alloc_unaligned (pool, old.length);
401 new->length = old.length;
402 memcpy (new->string, old.string, old.length);
405 /* Allocates room for a CNT-character string in NEW in POOL. */
407 ss_alloc_uninit_pool (struct substring *new, size_t cnt, struct pool *pool)
409 new->string = pool_alloc_unaligned (pool, cnt);
413 /* Frees the string that SS points to. */
415 ss_dealloc (struct substring *ss)
420 /* Truncates SS to at most CNT characters in length. */
422 ss_truncate (struct substring *ss, size_t cnt)
424 if (ss->length > cnt)
428 /* Removes trailing characters in TRIM_SET from SS.
429 Returns number of characters removed. */
431 ss_rtrim (struct substring *ss, struct substring trim_set)
434 while (cnt < ss->length
435 && ss_find_char (trim_set,
436 ss->string[ss->length - cnt - 1]) != SIZE_MAX)
442 /* Removes leading characters in TRIM_SET from SS.
443 Returns number of characters removed. */
445 ss_ltrim (struct substring *ss, struct substring trim_set)
447 size_t cnt = ss_span (*ss, trim_set);
448 ss_advance (ss, cnt);
452 /* Trims leading and trailing characters in TRIM_SET from SS. */
454 ss_trim (struct substring *ss, struct substring trim_set)
456 ss_ltrim (ss, trim_set);
457 ss_rtrim (ss, trim_set);
460 /* If the last character in SS is C, removes it and returns true.
461 Otherwise, returns false without changing the string. */
463 ss_chomp (struct substring *ss, char c)
465 if (ss_last (*ss) == c)
474 /* Divides SS into tokens separated by any of the DELIMITERS.
475 Each call replaces TOKEN by the next token in SS, or by an
476 empty string if no tokens remain. Returns true if a token was
477 obtained, false otherwise.
479 Before the first call, initialize *SAVE_IDX to 0. Do not
480 modify *SAVE_IDX between calls.
482 SS divides into exactly one more tokens than it contains
483 delimiters. That is, a delimiter at the start or end of SS or
484 a pair of adjacent delimiters yields an empty token, and the
485 empty string contains a single token. */
487 ss_separate (struct substring ss, struct substring delimiters,
488 size_t *save_idx, struct substring *token)
490 if (*save_idx <= ss_length (ss))
492 struct substring tmp = ss_substr (ss, *save_idx, SIZE_MAX);
493 size_t length = ss_cspan (tmp, delimiters);
494 *token = ss_head (tmp, length);
495 *save_idx += length + 1;
500 *token = ss_empty ();
505 /* Divides SS into tokens separated by any of the DELIMITERS,
506 merging adjacent delimiters so that the empty string is never
507 produced as a token. Each call replaces TOKEN by the next
508 token in SS, or by an empty string if no tokens remain, and
509 then skips past the first delimiter following the token.
510 Returns true if a token was obtained, false otherwise.
512 Before the first call, initialize *SAVE_IDX to 0. Do not
513 modify *SAVE_IDX between calls. */
515 ss_tokenize (struct substring ss, struct substring delimiters,
516 size_t *save_idx, struct substring *token)
518 ss_advance (&ss, *save_idx);
519 *save_idx += ss_ltrim (&ss, delimiters);
520 ss_get_chars (&ss, ss_cspan (ss, delimiters), token);
521 *save_idx += ss_length (*token) + 1;
522 return ss_length (*token) > 0;
525 /* Removes the first CNT characters from SS. */
527 ss_advance (struct substring *ss, size_t cnt)
529 if (cnt > ss->length)
535 /* If the first character in SS is C, removes it and returns true.
536 Otherwise, returns false without changing the string. */
538 ss_match_char (struct substring *ss, char c)
540 if (ss_first (*ss) == c)
550 /* If the first character in SS is in MATCH, removes it and
551 returns the character that was removed.
552 Otherwise, returns EOF without changing the string. */
554 ss_match_char_in (struct substring *ss, struct substring match)
558 && memchr (match.string, ss->string[0], match.length) != NULL)
567 /* If SS begins with TARGET, removes it and returns true.
568 Otherwise, returns false without changing SS. */
570 ss_match_string (struct substring *ss, const struct substring target)
572 size_t length = ss_length (target);
573 if (ss_equals (ss_head (*ss, length), target))
575 ss_advance (ss, length);
582 /* Removes the first character from SS and returns it.
583 If SS is empty, returns EOF without modifying SS. */
585 ss_get_char (struct substring *ss)
587 int c = ss_first (*ss);
596 /* Stores the prefix of SS up to the first DELIMITER in OUT (if
597 any). Trims those same characters from SS. DELIMITER is
598 removed from SS but not made part of OUT. Returns true if
599 DELIMITER was found (and removed), false otherwise. */
601 ss_get_until (struct substring *ss, char delimiter, struct substring *out)
603 ss_get_chars (ss, ss_cspan (*ss, ss_buffer (&delimiter, 1)), out);
604 return ss_match_char (ss, delimiter);
607 /* Stores the first CNT characters in SS in OUT (or fewer, if SS
608 is shorter than CNT characters). Trims the same characters
609 from the beginning of SS. Returns CNT. */
611 ss_get_chars (struct substring *ss, size_t cnt, struct substring *out)
613 *out = ss_head (*ss, cnt);
614 ss_advance (ss, cnt);
618 /* Parses and removes an optionally signed decimal integer from
619 the beginning of SS. Returns 0 if an error occurred,
620 otherwise the number of characters removed from SS. Stores
621 the integer's value into *VALUE. */
623 ss_get_long (struct substring *ss, long *value)
628 length = ss_span (*ss, ss_cstr ("+-"));
629 length += ss_span (ss_substr (*ss, length, SIZE_MAX), ss_cstr (CC_DIGITS));
630 if (length > 0 && length < sizeof tmp)
634 memcpy (tmp, ss_data (*ss), length);
637 *value = strtol (tmp, &tail, 10);
638 if (tail - tmp == length)
640 ss_advance (ss, length);
648 /* Returns true if SS is empty (contains no characters),
651 ss_is_empty (struct substring ss)
653 return ss.length == 0;
656 /* Returns the number of characters in SS. */
658 ss_length (struct substring ss)
663 /* Returns a pointer to the characters in SS. */
665 ss_data (struct substring ss)
670 /* Returns a pointer just past the last character in SS. */
672 ss_end (struct substring ss)
674 return ss.string + ss.length;
677 /* Returns the character in position IDX in SS, as a value in the
678 range of unsigned char. Returns EOF if IDX is out of the
679 range of indexes for SS. */
681 ss_at (struct substring ss, size_t idx)
683 return idx < ss.length ? (unsigned char) ss.string[idx] : EOF;
686 /* Returns the first character in SS as a value in the range of
687 unsigned char. Returns EOF if SS is the empty string. */
689 ss_first (struct substring ss)
691 return ss_at (ss, 0);
694 /* Returns the last character in SS as a value in the range of
695 unsigned char. Returns EOF if SS is the empty string. */
697 ss_last (struct substring ss)
699 return ss.length > 0 ? (unsigned char) ss.string[ss.length - 1] : EOF;
702 /* Returns the number of contiguous characters at the beginning
703 of SS that are in SKIP_SET. */
705 ss_span (struct substring ss, struct substring skip_set)
708 for (i = 0; i < ss.length; i++)
709 if (ss_find_char (skip_set, ss.string[i]) == SIZE_MAX)
714 /* Returns the number of contiguous characters at the beginning
715 of SS that are not in SKIP_SET. */
717 ss_cspan (struct substring ss, struct substring stop_set)
720 for (i = 0; i < ss.length; i++)
721 if (ss_find_char (stop_set, ss.string[i]) != SIZE_MAX)
726 /* Returns the offset in SS of the first instance of C,
727 or SIZE_MAX if C does not occur in SS. */
729 ss_find_char (struct substring ss, char c)
731 const char *p = memchr (ss.string, c, ss.length);
732 return p != NULL ? p - ss.string : SIZE_MAX;
735 /* Compares A and B and returns a strcmp()-type comparison
738 ss_compare (struct substring a, struct substring b)
740 int retval = memcmp (a.string, b.string, MIN (a.length, b.length));
742 retval = a.length < b.length ? -1 : a.length > b.length;
746 /* Compares A and B case-insensitively and returns a
747 strcmp()-type comparison result. */
749 ss_compare_case (struct substring a, struct substring b)
751 int retval = memcasecmp (a.string, b.string, MIN (a.length, b.length));
753 retval = a.length < b.length ? -1 : a.length > b.length;
757 /* Compares A and B and returns true if their contents are
758 identical, false otherwise. */
760 ss_equals (struct substring a, struct substring b)
762 return a.length == b.length && !memcmp (a.string, b.string, a.length);
765 /* Compares A and B and returns true if their contents are
766 identical except possibly for case differences, false
769 ss_equals_case (struct substring a, struct substring b)
771 return a.length == b.length && !memcasecmp (a.string, b.string, a.length);
774 /* Returns the position in SS that the character at P occupies.
775 P must point within SS or one past its end. */
777 ss_pointer_to_position (struct substring ss, const char *p)
779 size_t pos = p - ss.string;
780 assert (pos <= ss.length);
784 /* Allocates and returns a null-terminated string that contains
787 ss_xstrdup (struct substring ss)
789 char *s = xmalloc (ss.length + 1);
790 memcpy (s, ss.string, ss.length);
795 /* Initializes ST as an empty string. */
797 ds_init_empty (struct string *st)
799 st->ss = ss_empty ();
803 /* Initializes ST with initial contents S. */
805 ds_init_string (struct string *st, const struct string *s)
807 ds_init_substring (st, ds_ss (s));
810 /* Initializes ST with initial contents SS. */
812 ds_init_substring (struct string *st, struct substring ss)
814 st->capacity = MAX (8, ss.length * 2);
815 st->ss.string = xmalloc (st->capacity + 1);
816 memcpy (st->ss.string, ss.string, ss.length);
817 st->ss.length = ss.length;
820 /* Initializes ST with initial contents S. */
822 ds_init_cstr (struct string *st, const char *s)
824 ds_init_substring (st, ss_cstr (s));
829 ds_destroy (struct string *st)
833 ss_dealloc (&st->ss);
834 st->ss.string = NULL;
840 /* Swaps the contents of strings A and B. */
842 ds_swap (struct string *a, struct string *b)
844 struct string tmp = *a;
849 /* Helper function for ds_register_pool. */
851 free_string (void *st_)
853 struct string *st = st_;
857 /* Arranges for ST to be destroyed automatically as part of
860 ds_register_pool (struct string *st, struct pool *pool)
862 pool_register (pool, free_string, st);
865 /* Cancels the arrangement for ST to be destroyed automatically
868 ds_unregister_pool (struct string *st, struct pool *pool)
870 pool_unregister (pool, st);
873 /* Copies SRC into DST.
874 DST and SRC may be the same string. */
876 ds_assign_string (struct string *dst, const struct string *src)
878 ds_assign_substring (dst, ds_ss (src));
881 /* Replaces DST by SS.
882 SS may be a substring of DST. */
884 ds_assign_substring (struct string *dst, struct substring ss)
886 dst->ss.length = ss.length;
887 ds_extend (dst, ss.length);
888 memmove (dst->ss.string, ss.string, ss.length);
891 /* Replaces DST by null-terminated string SRC. SRC may overlap
894 ds_assign_cstr (struct string *dst, const char *src)
896 ds_assign_substring (dst, ss_cstr (src));
899 /* Truncates ST to zero length. */
901 ds_clear (struct string *st)
906 /* Returns a substring that contains ST. */
908 ds_ss (const struct string *st)
913 /* Returns a substring that contains CNT characters from ST
914 starting at position START.
916 If START is greater than or equal to the length of ST, then
917 the substring will be the empty string. If START + CNT
918 exceeds the length of ST, then the substring will only be
919 ds_length(ST) - START characters long. */
921 ds_substr (const struct string *st, size_t start, size_t cnt)
923 return ss_substr (ds_ss (st), start, cnt);
926 /* Returns a substring that contains the first CNT characters in
927 ST. If CNT exceeds the length of ST, then the substring will
928 contain all of ST. */
930 ds_head (const struct string *st, size_t cnt)
932 return ss_head (ds_ss (st), cnt);
935 /* Returns a substring that contains the last CNT characters in
936 ST. If CNT exceeds the length of ST, then the substring will
937 contain all of ST. */
939 ds_tail (const struct string *st, size_t cnt)
941 return ss_tail (ds_ss (st), cnt);
944 /* Ensures that ST can hold at least MIN_CAPACITY characters plus a null
947 ds_extend (struct string *st, size_t min_capacity)
949 if (min_capacity > st->capacity)
952 if (st->capacity < min_capacity)
953 st->capacity = 2 * min_capacity;
955 st->ss.string = xrealloc (st->ss.string, st->capacity + 1);
959 /* Shrink ST to the minimum capacity need to contain its content. */
961 ds_shrink (struct string *st)
963 if (st->capacity != st->ss.length)
965 st->capacity = st->ss.length;
966 st->ss.string = xrealloc (st->ss.string, st->capacity + 1);
970 /* Truncates ST to at most LENGTH characters long. */
972 ds_truncate (struct string *st, size_t length)
974 ss_truncate (&st->ss, length);
977 /* Removes trailing characters in TRIM_SET from ST.
978 Returns number of characters removed. */
980 ds_rtrim (struct string *st, struct substring trim_set)
982 return ss_rtrim (&st->ss, trim_set);
985 /* Removes leading characters in TRIM_SET from ST.
986 Returns number of characters removed. */
988 ds_ltrim (struct string *st, struct substring trim_set)
990 size_t cnt = ds_span (st, trim_set);
992 ds_assign_substring (st, ds_substr (st, cnt, SIZE_MAX));
996 /* Trims leading and trailing characters in TRIM_SET from ST.
997 Returns number of charactesr removed. */
999 ds_trim (struct string *st, struct substring trim_set)
1001 size_t cnt = ds_rtrim (st, trim_set);
1002 return cnt + ds_ltrim (st, trim_set);
1005 /* If the last character in ST is C, removes it and returns true.
1006 Otherwise, returns false without modifying ST. */
1008 ds_chomp (struct string *st, char c)
1010 return ss_chomp (&st->ss, c);
1013 /* Divides ST into tokens separated by any of the DELIMITERS.
1014 Each call replaces TOKEN by the next token in ST, or by an
1015 empty string if no tokens remain. Returns true if a token was
1016 obtained, false otherwise.
1018 Before the first call, initialize *SAVE_IDX to 0. Do not
1019 modify *SAVE_IDX between calls.
1021 ST divides into exactly one more tokens than it contains
1022 delimiters. That is, a delimiter at the start or end of ST or
1023 a pair of adjacent delimiters yields an empty token, and the
1024 empty string contains a single token. */
1026 ds_separate (const struct string *st, struct substring delimiters,
1027 size_t *save_idx, struct substring *token)
1029 return ss_separate (ds_ss (st), delimiters, save_idx, token);
1032 /* Divides ST into tokens separated by any of the DELIMITERS,
1033 merging adjacent delimiters so that the empty string is never
1034 produced as a token. Each call replaces TOKEN by the next
1035 token in ST, or by an empty string if no tokens remain.
1036 Returns true if a token was obtained, false otherwise.
1038 Before the first call, initialize *SAVE_IDX to 0. Do not
1039 modify *SAVE_IDX between calls. */
1041 ds_tokenize (const struct string *st, struct substring delimiters,
1042 size_t *save_idx, struct substring *token)
1044 return ss_tokenize (ds_ss (st), delimiters, save_idx, token);
1047 /* Pad ST on the right with copies of PAD until ST is at least
1048 LENGTH characters in size. If ST is initially LENGTH
1049 characters or longer, this is a no-op. */
1051 ds_rpad (struct string *st, size_t length, char pad)
1053 if (length > st->ss.length)
1054 ds_put_char_multiple (st, pad, length - st->ss.length);
1057 /* Sets the length of ST to exactly NEW_LENGTH,
1058 either by truncating characters from the end,
1059 or by padding on the right with PAD. */
1061 ds_set_length (struct string *st, size_t new_length, char pad)
1063 if (st->ss.length < new_length)
1064 ds_rpad (st, new_length, pad);
1066 st->ss.length = new_length;
1069 /* Returns true if ST is empty, false otherwise. */
1071 ds_is_empty (const struct string *st)
1073 return ss_is_empty (st->ss);
1076 /* Returns the length of ST. */
1078 ds_length (const struct string *st)
1080 return ss_length (ds_ss (st));
1083 /* Returns the string data inside ST. */
1085 ds_data (const struct string *st)
1087 return ss_data (ds_ss (st));
1090 /* Returns a pointer to the null terminator ST.
1091 This might not be an actual null character unless ds_c_str() has
1092 been called since the last modification to ST. */
1094 ds_end (const struct string *st)
1096 return ss_end (ds_ss (st));
1099 /* Returns the character in position IDX in ST, as a value in the
1100 range of unsigned char. Returns EOF if IDX is out of the
1101 range of indexes for ST. */
1103 ds_at (const struct string *st, size_t idx)
1105 return ss_at (ds_ss (st), idx);
1108 /* Returns the first character in ST as a value in the range of
1109 unsigned char. Returns EOF if ST is the empty string. */
1111 ds_first (const struct string *st)
1113 return ss_first (ds_ss (st));
1116 /* Returns the last character in ST as a value in the range of
1117 unsigned char. Returns EOF if ST is the empty string. */
1119 ds_last (const struct string *st)
1121 return ss_last (ds_ss (st));
1124 /* Returns the number of consecutive characters at the beginning
1125 of ST that are in SKIP_SET. */
1127 ds_span (const struct string *st, struct substring skip_set)
1129 return ss_span (ds_ss (st), skip_set);
1132 /* Returns the number of consecutive characters at the beginning
1133 of ST that are not in STOP_SET. */
1135 ds_cspan (const struct string *st, struct substring stop_set)
1137 return ss_cspan (ds_ss (st), stop_set);
1140 /* Returns the position of the first occurrence of character C in
1141 ST at or after position OFS, or SIZE_MAX if there is no such
1144 ds_find_char (const struct string *st, char c)
1146 return ss_find_char (ds_ss (st), c);
1149 /* Compares A and B and returns a strcmp()-type comparison
1152 ds_compare (const struct string *a, const struct string *b)
1154 return ss_compare (ds_ss (a), ds_ss (b));
1157 /* Returns the position in ST that the character at P occupies.
1158 P must point within ST or one past its end. */
1160 ds_pointer_to_position (const struct string *st, const char *p)
1162 return ss_pointer_to_position (ds_ss (st), p);
1165 /* Allocates and returns a null-terminated string that contains
1168 ds_xstrdup (const struct string *st)
1170 return ss_xstrdup (ds_ss (st));
1173 /* Returns the allocation size of ST. */
1175 ds_capacity (const struct string *st)
1177 return st->capacity;
1180 /* Returns the value of ST as a null-terminated string. */
1182 ds_cstr (const struct string *st_)
1184 struct string *st = (struct string *) st_;
1185 if (st->ss.string == NULL)
1187 st->ss.string[st->ss.length] = '\0';
1188 return st->ss.string;
1191 /* Appends to ST a newline-terminated line read from STREAM, but
1192 no more than MAX_LENGTH characters.
1193 Newline is the last character of ST on return, if encountering
1194 a newline was the reason for terminating.
1195 Returns true if at least one character was read from STREAM
1196 and appended to ST, false if no characters at all were read
1197 before an I/O error or end of file was encountered (or
1198 MAX_LENGTH was 0). */
1200 ds_read_line (struct string *st, FILE *stream, size_t max_length)
1202 if (!st->ss.length && max_length == SIZE_MAX)
1204 size_t capacity = st->capacity ? st->capacity + 1 : 0;
1205 ssize_t n = getline (&st->ss.string, &capacity, stream);
1207 st->capacity = capacity - 1;
1220 for (length = 0; length < max_length; length++)
1222 int c = getc (stream);
1226 ds_put_char (st, c);
1235 /* Removes a comment introduced by `#' from ST,
1236 ignoring occurrences inside quoted strings. */
1238 remove_comment (struct string *st)
1243 for (cp = ds_data (st); cp < ds_end (st); cp++)
1248 else if (*cp == '\\')
1251 else if (*cp == '\'' || *cp == '"')
1253 else if (*cp == '#')
1255 ds_truncate (st, cp - ds_cstr (st));
1260 /* Reads a line from STREAM into ST, then preprocesses as follows:
1262 - Splices lines terminated with `\'.
1264 - Deletes comments introduced by `#' outside of single or double
1267 - Deletes trailing white space.
1269 Returns true if a line was successfully read, false on
1270 failure. If LINE_NUMBER is non-null, then *LINE_NUMBER is
1271 incremented by the number of lines read. */
1273 ds_read_config_line (struct string *st, int *line_number, FILE *stream)
1278 if (!ds_read_line (st, stream, SIZE_MAX))
1281 ds_rtrim (st, ss_cstr (CC_SPACES));
1283 while (ds_chomp (st, '\\'));
1285 remove_comment (st);
1289 /* Attempts to read SIZE * CNT bytes from STREAM and append them
1291 Returns true if all the requested data was read, false otherwise. */
1293 ds_read_stream (struct string *st, size_t size, size_t cnt, FILE *stream)
1297 size_t try_bytes = xtimes (cnt, size);
1298 if (size_in_bounds_p (xsum (ds_length (st), try_bytes)))
1300 char *buffer = ds_put_uninit (st, try_bytes);
1301 size_t got_bytes = fread (buffer, 1, try_bytes, stream);
1302 ds_truncate (st, ds_length (st) - (try_bytes - got_bytes));
1303 return got_bytes == try_bytes;
1315 /* Concatenates S onto ST. */
1317 ds_put_cstr (struct string *st, const char *s)
1320 ds_put_substring (st, ss_cstr (s));
1323 /* Concatenates SS to ST. */
1325 ds_put_substring (struct string *st, struct substring ss)
1327 memcpy (ds_put_uninit (st, ss_length (ss)), ss_data (ss), ss_length (ss));
1330 /* Returns ds_end(ST) and THEN increases the length by INCR. */
1332 ds_put_uninit (struct string *st, size_t incr)
1335 ds_extend (st, ds_length (st) + incr);
1337 st->ss.length += incr;
1341 /* Formats FORMAT as a printf string and appends the result to ST. */
1343 ds_put_format (struct string *st, const char *format, ...)
1347 va_start (args, format);
1348 ds_put_vformat (st, format, args);
1352 /* Formats FORMAT as a printf string and appends the result to ST. */
1354 ds_put_vformat (struct string *st, const char *format, va_list args_)
1359 va_copy (args, args_);
1360 avail = st->ss.string != NULL ? st->capacity - st->ss.length + 1 : 0;
1361 needed = vsnprintf (st->ss.string + st->ss.length, avail, format, args);
1364 if (needed >= avail)
1366 va_copy (args, args_);
1367 vsprintf (ds_put_uninit (st, needed), format, args);
1372 /* Some old libc's returned -1 when the destination string
1374 while (needed == -1)
1376 ds_extend (st, (st->capacity + 1) * 2);
1377 avail = st->capacity - st->ss.length + 1;
1379 va_copy (args, args_);
1380 needed = vsnprintf (ds_end (st), avail, format, args);
1383 st->ss.length += needed;
1387 /* Appends character CH to ST. */
1389 ds_put_char (struct string *st, int ch)
1391 ds_put_uninit (st, 1)[0] = ch;
1394 /* Appends CNT copies of character CH to ST. */
1396 ds_put_char_multiple (struct string *st, int ch, size_t cnt)
1398 memset (ds_put_uninit (st, cnt), ch, cnt);
1402 /* If relocation has been enabled, replace ST,
1403 with its relocated version */
1405 ds_relocate (struct string *st)
1407 const char *orig = ds_cstr (st);
1408 const char *rel = relocate (orig);
1413 ds_put_cstr (st, rel);
1414 free ((char *) rel);