1 /* PSPP - a program for statistical analysis.
2 Copyright (C) 1997-9, 2000, 2006, 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/>. */
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
128 copies of PAD as needed. */
130 buf_copy_str_rpad (char *dst, size_t dst_size, const char *src, char pad)
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], pad, 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
144 copies of PAD as needed. */
146 buf_copy_str_lpad (char *dst, size_t dst_size, const char *src, char pad)
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, 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
161 copies of PAD as needed. */
163 buf_copy_lpad (char *dst, size_t dst_size,
164 const char *src, size_t src_size,
167 if (src_size >= dst_size)
168 memmove (dst, src, dst_size);
171 memset (dst, pad, dst_size - src_size);
172 memmove (&dst[dst_size - src_size], src, src_size);
176 /* Copies buffer SRC, of SRC_SIZE bytes, to DST, of DST_SIZE bytes.
177 DST is truncated to DST_SIZE bytes or padded on the right with
178 copies of PAD as needed. */
180 buf_copy_rpad (char *dst, size_t dst_size,
181 const char *src, size_t src_size,
184 if (src_size >= dst_size)
185 memmove (dst, src, dst_size);
188 memmove (dst, src, src_size);
189 memset (&dst[src_size], pad, dst_size - src_size);
193 /* Copies string SRC to string DST, which is in a buffer DST_SIZE
195 Truncates DST to DST_SIZE - 1 characters or right-pads with
196 spaces to DST_SIZE - 1 characters if necessary. */
198 str_copy_rpad (char *dst, size_t dst_size, const char *src)
202 size_t src_len = strlen (src);
203 if (src_len < dst_size - 1)
205 memcpy (dst, src, src_len);
206 memset (&dst[src_len], ' ', dst_size - 1 - src_len);
209 memcpy (dst, src, dst_size - 1);
210 dst[dst_size - 1] = 0;
214 /* Copies SRC to DST, which is in a buffer DST_SIZE bytes long.
215 Truncates DST to DST_SIZE - 1 characters, if necessary. */
217 str_copy_trunc (char *dst, size_t dst_size, const char *src)
219 size_t src_len = strlen (src);
220 assert (dst_size > 0);
221 if (src_len + 1 < dst_size)
222 memcpy (dst, src, src_len + 1);
225 memcpy (dst, src, dst_size - 1);
226 dst[dst_size - 1] = '\0';
230 /* Copies buffer SRC, of SRC_LEN bytes,
231 to DST, which is in a buffer DST_SIZE bytes long.
232 Truncates DST to DST_SIZE - 1 characters, if necessary. */
234 str_copy_buf_trunc (char *dst, size_t dst_size,
235 const char *src, size_t src_size)
238 assert (dst_size > 0);
240 dst_len = src_size < dst_size ? src_size : dst_size - 1;
241 memcpy (dst, src, dst_len);
245 /* Converts each character in S to uppercase. */
247 str_uppercase (char *s)
249 for (; *s != '\0'; s++)
250 *s = toupper ((unsigned char) *s);
253 /* Converts each character in S to lowercase. */
255 str_lowercase (char *s)
257 for (; *s != '\0'; s++)
258 *s = tolower ((unsigned char) *s);
261 /* Converts NUMBER into a string in 26-adic notation in BUFFER,
262 which has room for SIZE bytes. Returns true if successful,
263 false if NUMBER, plus a trailing null, is too large to fit in
266 26-adic notation is "spreadsheet column numbering": 1 = A, 2 =
267 B, 3 = C, ... 26 = Z, 27 = AA, 28 = AB, 29 = AC, ...
269 26-adic notation is the special case of a k-adic numeration
270 system (aka bijective base-k numeration) with k=26. In k-adic
271 numeration, the digits are {1, 2, 3, ..., k} (there is no
272 digit 0), and integer 0 is represented by the empty string.
273 For more information, see
274 http://en.wikipedia.org/wiki/Bijective_numeration. */
276 str_format_26adic (unsigned long int number, char buffer[], size_t size)
284 buffer[length++] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"[number % 26];
290 buffer[length] = '\0';
292 buf_reverse (buffer, length);
296 /* Formats FORMAT into DST, as with sprintf(), and returns the
297 address of the terminating null written to DST. */
299 spprintf (char *dst, const char *format, ...)
304 va_start (args, format);
305 count = vsprintf (dst, format, args);
311 /* Sets the SIZE bytes starting at BLOCK to C,
312 and returns the byte following BLOCK. */
314 mempset (void *block, int c, size_t size)
316 memset (block, c, size);
317 return (char *) block + size;
322 /* Returns an empty substring. */
332 /* Returns a substring whose contents are the given C-style
335 ss_cstr (const char *cstr)
337 return ss_buffer (cstr, strlen (cstr));
340 /* Returns a substring whose contents are the CNT characters in
343 ss_buffer (const char *buffer, size_t cnt)
346 ss.string = (char *) buffer;
351 /* Returns a substring whose contents are the CNT characters
352 starting at the (0-based) position START in SS. */
354 ss_substr (struct substring ss, size_t start, size_t cnt)
356 if (start < ss.length)
357 return ss_buffer (ss.string + start, MIN (cnt, ss.length - start));
359 return ss_buffer (ss.string + ss.length, 0);
362 /* Returns a substring whose contents are the first CNT
365 ss_head (struct substring ss, size_t cnt)
367 return ss_buffer (ss.string, MIN (cnt, ss.length));
370 /* Returns a substring whose contents are the last CNT characters
373 ss_tail (struct substring ss, size_t cnt)
376 return ss_buffer (ss.string + (ss.length - cnt), cnt);
381 /* Makes a malloc()'d copy of the contents of OLD
382 and stores it in NEW. */
384 ss_alloc_substring (struct substring *new, struct substring old)
386 new->string = xmalloc (old.length);
387 new->length = old.length;
388 memcpy (new->string, old.string, old.length);
391 /* Allocates room for a CNT-character string in NEW. */
393 ss_alloc_uninit (struct substring *new, size_t cnt)
395 new->string = xmalloc (cnt);
399 /* Makes a pool_alloc_unaligned()'d copy of the contents of OLD
400 in POOL, and stores it in NEW. */
402 ss_alloc_substring_pool (struct substring *new, struct substring old,
405 new->string = pool_alloc_unaligned (pool, old.length);
406 new->length = old.length;
407 memcpy (new->string, old.string, old.length);
410 /* Allocates room for a CNT-character string in NEW in POOL. */
412 ss_alloc_uninit_pool (struct substring *new, size_t cnt, struct pool *pool)
414 new->string = pool_alloc_unaligned (pool, cnt);
418 /* Frees the string that SS points to. */
420 ss_dealloc (struct substring *ss)
425 /* Truncates SS to at most CNT characters in length. */
427 ss_truncate (struct substring *ss, size_t cnt)
429 if (ss->length > cnt)
433 /* Removes trailing characters in TRIM_SET from SS.
434 Returns number of characters removed. */
436 ss_rtrim (struct substring *ss, struct substring trim_set)
439 while (cnt < ss->length
440 && ss_find_char (trim_set,
441 ss->string[ss->length - cnt - 1]) != SIZE_MAX)
447 /* Removes leading characters in TRIM_SET from SS.
448 Returns number of characters removed. */
450 ss_ltrim (struct substring *ss, struct substring trim_set)
452 size_t cnt = ss_span (*ss, trim_set);
453 ss_advance (ss, cnt);
457 /* Trims leading and trailing characters in TRIM_SET from SS. */
459 ss_trim (struct substring *ss, struct substring trim_set)
461 ss_ltrim (ss, trim_set);
462 ss_rtrim (ss, trim_set);
465 /* If the last character in SS is C, removes it and returns true.
466 Otherwise, returns false without changing the string. */
468 ss_chomp (struct substring *ss, char c)
470 if (ss_last (*ss) == c)
479 /* Divides SS into tokens separated by any of the DELIMITERS.
480 Each call replaces TOKEN by the next token in SS, or by an
481 empty string if no tokens remain. Returns true if a token was
482 obtained, false otherwise.
484 Before the first call, initialize *SAVE_IDX to 0. Do not
485 modify *SAVE_IDX between calls.
487 SS divides into exactly one more tokens than it contains
488 delimiters. That is, a delimiter at the start or end of SS or
489 a pair of adjacent delimiters yields an empty token, and the
490 empty string contains a single token. */
492 ss_separate (struct substring ss, struct substring delimiters,
493 size_t *save_idx, struct substring *token)
495 if (*save_idx <= ss_length (ss))
497 struct substring tmp = ss_substr (ss, *save_idx, SIZE_MAX);
498 size_t length = ss_cspan (tmp, delimiters);
499 *token = ss_head (tmp, length);
500 *save_idx += length + 1;
505 *token = ss_empty ();
510 /* Divides SS into tokens separated by any of the DELIMITERS,
511 merging adjacent delimiters so that the empty string is never
512 produced as a token. Each call replaces TOKEN by the next
513 token in SS, or by an empty string if no tokens remain, and
514 then skips past the first delimiter following the token.
515 Returns true if a token was obtained, false otherwise.
517 Before the first call, initialize *SAVE_IDX to 0. Do not
518 modify *SAVE_IDX between calls. */
520 ss_tokenize (struct substring ss, struct substring delimiters,
521 size_t *save_idx, struct substring *token)
523 ss_advance (&ss, *save_idx);
524 *save_idx += ss_ltrim (&ss, delimiters);
525 ss_get_chars (&ss, ss_cspan (ss, delimiters), token);
526 *save_idx += ss_length (*token) + 1;
527 return ss_length (*token) > 0;
530 /* Removes the first CNT characters from SS. */
532 ss_advance (struct substring *ss, size_t cnt)
534 if (cnt > ss->length)
540 /* If the first character in SS is C, removes it and returns true.
541 Otherwise, returns false without changing the string. */
543 ss_match_char (struct substring *ss, char c)
545 if (ss_first (*ss) == c)
555 /* If the first character in SS is in MATCH, removes it and
556 returns the character that was removed.
557 Otherwise, returns EOF without changing the string. */
559 ss_match_char_in (struct substring *ss, struct substring match)
563 && memchr (match.string, ss->string[0], match.length) != NULL)
572 /* If SS begins with TARGET, removes it and returns true.
573 Otherwise, returns false without changing SS. */
575 ss_match_string (struct substring *ss, const struct substring target)
577 size_t length = ss_length (target);
578 if (ss_equals (ss_head (*ss, length), target))
580 ss_advance (ss, length);
587 /* Removes the first character from SS and returns it.
588 If SS is empty, returns EOF without modifying SS. */
590 ss_get_char (struct substring *ss)
592 int c = ss_first (*ss);
601 /* Stores the prefix of SS up to the first DELIMITER in OUT (if
602 any). Trims those same characters from SS. DELIMITER is
603 removed from SS but not made part of OUT. Returns true if
604 DELIMITER was found (and removed), false otherwise. */
606 ss_get_until (struct substring *ss, char delimiter, struct substring *out)
608 ss_get_chars (ss, ss_cspan (*ss, ss_buffer (&delimiter, 1)), out);
609 return ss_match_char (ss, delimiter);
612 /* Stores the first CNT characters in SS in OUT (or fewer, if SS
613 is shorter than CNT characters). Trims the same characters
614 from the beginning of SS. Returns CNT. */
616 ss_get_chars (struct substring *ss, size_t cnt, struct substring *out)
618 *out = ss_head (*ss, cnt);
619 ss_advance (ss, cnt);
623 /* Parses and removes an optionally signed decimal integer from
624 the beginning of SS. Returns 0 if an error occurred,
625 otherwise the number of characters removed from SS. Stores
626 the integer's value into *VALUE. */
628 ss_get_long (struct substring *ss, long *value)
633 length = ss_span (*ss, ss_cstr ("+-"));
634 length += ss_span (ss_substr (*ss, length, SIZE_MAX), ss_cstr (CC_DIGITS));
635 if (length > 0 && length < sizeof tmp)
639 memcpy (tmp, ss_data (*ss), length);
642 *value = strtol (tmp, &tail, 10);
643 if (tail - tmp == length)
645 ss_advance (ss, length);
653 /* Returns true if SS is empty (contains no characters),
656 ss_is_empty (struct substring ss)
658 return ss.length == 0;
661 /* Returns the number of characters in SS. */
663 ss_length (struct substring ss)
668 /* Returns a pointer to the characters in SS. */
670 ss_data (struct substring ss)
675 /* Returns a pointer just past the last character in SS. */
677 ss_end (struct substring ss)
679 return ss.string + ss.length;
682 /* Returns the character in position IDX in SS, as a value in the
683 range of unsigned char. Returns EOF if IDX is out of the
684 range of indexes for SS. */
686 ss_at (struct substring ss, size_t idx)
688 return idx < ss.length ? (unsigned char) ss.string[idx] : EOF;
691 /* Returns the first character in SS as a value in the range of
692 unsigned char. Returns EOF if SS is the empty string. */
694 ss_first (struct substring ss)
696 return ss_at (ss, 0);
699 /* Returns the last character in SS as a value in the range of
700 unsigned char. Returns EOF if SS is the empty string. */
702 ss_last (struct substring ss)
704 return ss.length > 0 ? (unsigned char) ss.string[ss.length - 1] : EOF;
707 /* Returns the number of contiguous characters at the beginning
708 of SS that are in SKIP_SET. */
710 ss_span (struct substring ss, struct substring skip_set)
713 for (i = 0; i < ss.length; i++)
714 if (ss_find_char (skip_set, ss.string[i]) == SIZE_MAX)
719 /* Returns the number of contiguous characters at the beginning
720 of SS that are not in SKIP_SET. */
722 ss_cspan (struct substring ss, struct substring stop_set)
725 for (i = 0; i < ss.length; i++)
726 if (ss_find_char (stop_set, ss.string[i]) != SIZE_MAX)
731 /* Returns the offset in SS of the first instance of C,
732 or SIZE_MAX if C does not occur in SS. */
734 ss_find_char (struct substring ss, char c)
736 const char *p = memchr (ss.string, c, ss.length);
737 return p != NULL ? p - ss.string : SIZE_MAX;
740 /* Compares A and B and returns a strcmp()-type comparison
743 ss_compare (struct substring a, struct substring b)
745 int retval = memcmp (a.string, b.string, MIN (a.length, b.length));
747 retval = a.length < b.length ? -1 : a.length > b.length;
751 /* Compares A and B case-insensitively and returns a
752 strcmp()-type comparison result. */
754 ss_compare_case (struct substring a, struct substring b)
756 int retval = memcasecmp (a.string, b.string, MIN (a.length, b.length));
758 retval = a.length < b.length ? -1 : a.length > b.length;
762 /* Compares A and B and returns true if their contents are
763 identical, false otherwise. */
765 ss_equals (struct substring a, struct substring b)
767 return a.length == b.length && !memcmp (a.string, b.string, a.length);
770 /* Compares A and B and returns true if their contents are
771 identical except possibly for case differences, false
774 ss_equals_case (struct substring a, struct substring b)
776 return a.length == b.length && !memcasecmp (a.string, b.string, a.length);
779 /* Returns the position in SS that the character at P occupies.
780 P must point within SS or one past its end. */
782 ss_pointer_to_position (struct substring ss, const char *p)
784 size_t pos = p - ss.string;
785 assert (pos <= ss.length);
789 /* Allocates and returns a null-terminated string that contains
792 ss_xstrdup (struct substring ss)
794 char *s = xmalloc (ss.length + 1);
795 memcpy (s, ss.string, ss.length);
800 /* Initializes ST as an empty string. */
802 ds_init_empty (struct string *st)
804 st->ss = ss_empty ();
808 /* Initializes ST with initial contents S. */
810 ds_init_string (struct string *st, const struct string *s)
812 ds_init_substring (st, ds_ss (s));
815 /* Initializes ST with initial contents SS. */
817 ds_init_substring (struct string *st, struct substring ss)
819 st->capacity = MAX (8, ss.length * 2);
820 st->ss.string = xmalloc (st->capacity + 1);
821 memcpy (st->ss.string, ss.string, ss.length);
822 st->ss.length = ss.length;
825 /* Initializes ST with initial contents S. */
827 ds_init_cstr (struct string *st, const char *s)
829 ds_init_substring (st, ss_cstr (s));
834 ds_destroy (struct string *st)
838 ss_dealloc (&st->ss);
839 st->ss.string = NULL;
845 /* Swaps the contents of strings A and B. */
847 ds_swap (struct string *a, struct string *b)
849 struct string tmp = *a;
854 /* Helper function for ds_register_pool. */
856 free_string (void *st_)
858 struct string *st = st_;
862 /* Arranges for ST to be destroyed automatically as part of
865 ds_register_pool (struct string *st, struct pool *pool)
867 pool_register (pool, free_string, st);
870 /* Cancels the arrangement for ST to be destroyed automatically
873 ds_unregister_pool (struct string *st, struct pool *pool)
875 pool_unregister (pool, st);
878 /* Copies SRC into DST.
879 DST and SRC may be the same string. */
881 ds_assign_string (struct string *dst, const struct string *src)
883 ds_assign_substring (dst, ds_ss (src));
886 /* Replaces DST by SS.
887 SS may be a substring of DST. */
889 ds_assign_substring (struct string *dst, struct substring ss)
891 dst->ss.length = ss.length;
892 ds_extend (dst, ss.length);
893 memmove (dst->ss.string, ss.string, ss.length);
896 /* Replaces DST by null-terminated string SRC. SRC may overlap
899 ds_assign_cstr (struct string *dst, const char *src)
901 ds_assign_substring (dst, ss_cstr (src));
904 /* Truncates ST to zero length. */
906 ds_clear (struct string *st)
911 /* Returns a substring that contains ST. */
913 ds_ss (const struct string *st)
918 /* Returns a substring that contains CNT characters from ST
919 starting at position START.
921 If START is greater than or equal to the length of ST, then
922 the substring will be the empty string. If START + CNT
923 exceeds the length of ST, then the substring will only be
924 ds_length(ST) - START characters long. */
926 ds_substr (const struct string *st, size_t start, size_t cnt)
928 return ss_substr (ds_ss (st), start, cnt);
931 /* Returns a substring that contains the first CNT characters in
932 ST. If CNT exceeds the length of ST, then the substring will
933 contain all of ST. */
935 ds_head (const struct string *st, size_t cnt)
937 return ss_head (ds_ss (st), cnt);
940 /* Returns a substring that contains the last CNT characters in
941 ST. If CNT exceeds the length of ST, then the substring will
942 contain all of ST. */
944 ds_tail (const struct string *st, size_t cnt)
946 return ss_tail (ds_ss (st), cnt);
949 /* Ensures that ST can hold at least MIN_CAPACITY characters plus a null
952 ds_extend (struct string *st, size_t min_capacity)
954 if (min_capacity > st->capacity)
957 if (st->capacity < min_capacity)
958 st->capacity = 2 * min_capacity;
960 st->ss.string = xrealloc (st->ss.string, st->capacity + 1);
964 /* Shrink ST to the minimum capacity need to contain its content. */
966 ds_shrink (struct string *st)
968 if (st->capacity != st->ss.length)
970 st->capacity = st->ss.length;
971 st->ss.string = xrealloc (st->ss.string, st->capacity + 1);
975 /* Truncates ST to at most LENGTH characters long. */
977 ds_truncate (struct string *st, size_t length)
979 ss_truncate (&st->ss, length);
982 /* Removes trailing characters in TRIM_SET from ST.
983 Returns number of characters removed. */
985 ds_rtrim (struct string *st, struct substring trim_set)
987 return ss_rtrim (&st->ss, trim_set);
990 /* Removes leading characters in TRIM_SET from ST.
991 Returns number of characters removed. */
993 ds_ltrim (struct string *st, struct substring trim_set)
995 size_t cnt = ds_span (st, trim_set);
997 ds_assign_substring (st, ds_substr (st, cnt, SIZE_MAX));
1001 /* Trims leading and trailing characters in TRIM_SET from ST.
1002 Returns number of charactesr removed. */
1004 ds_trim (struct string *st, struct substring trim_set)
1006 size_t cnt = ds_rtrim (st, trim_set);
1007 return cnt + ds_ltrim (st, trim_set);
1010 /* If the last character in ST is C, removes it and returns true.
1011 Otherwise, returns false without modifying ST. */
1013 ds_chomp (struct string *st, char c)
1015 return ss_chomp (&st->ss, c);
1018 /* Divides ST into tokens separated by any of the DELIMITERS.
1019 Each call replaces TOKEN by the next token in ST, or by an
1020 empty string if no tokens remain. Returns true if a token was
1021 obtained, false otherwise.
1023 Before the first call, initialize *SAVE_IDX to 0. Do not
1024 modify *SAVE_IDX between calls.
1026 ST divides into exactly one more tokens than it contains
1027 delimiters. That is, a delimiter at the start or end of ST or
1028 a pair of adjacent delimiters yields an empty token, and the
1029 empty string contains a single token. */
1031 ds_separate (const struct string *st, struct substring delimiters,
1032 size_t *save_idx, struct substring *token)
1034 return ss_separate (ds_ss (st), delimiters, save_idx, token);
1037 /* Divides ST into tokens separated by any of the DELIMITERS,
1038 merging adjacent delimiters so that the empty string is never
1039 produced as a token. Each call replaces TOKEN by the next
1040 token in ST, or by an empty string if no tokens remain.
1041 Returns true if a token was obtained, false otherwise.
1043 Before the first call, initialize *SAVE_IDX to 0. Do not
1044 modify *SAVE_IDX between calls. */
1046 ds_tokenize (const struct string *st, struct substring delimiters,
1047 size_t *save_idx, struct substring *token)
1049 return ss_tokenize (ds_ss (st), delimiters, save_idx, token);
1052 /* Pad ST on the right with copies of PAD until ST is at least
1053 LENGTH characters in size. If ST is initially LENGTH
1054 characters or longer, this is a no-op. */
1056 ds_rpad (struct string *st, size_t length, char pad)
1058 if (length > st->ss.length)
1059 ds_put_char_multiple (st, pad, length - st->ss.length);
1062 /* Sets the length of ST to exactly NEW_LENGTH,
1063 either by truncating characters from the end,
1064 or by padding on the right with PAD. */
1066 ds_set_length (struct string *st, size_t new_length, char pad)
1068 if (st->ss.length < new_length)
1069 ds_rpad (st, new_length, pad);
1071 st->ss.length = new_length;
1074 /* Removes N characters from ST starting at offset START. */
1076 ds_remove (struct string *st, size_t start, size_t n)
1078 if (n > 0 && start < st->ss.length)
1080 if (st->ss.length - start <= n)
1082 /* All characters at or beyond START are deleted. */
1083 st->ss.length = start;
1087 /* Some characters remain and must be shifted into
1089 memmove (st->ss.string + st->ss.length,
1090 st->ss.string + st->ss.length + n,
1091 st->ss.length - start - n);
1097 /* There are no characters to delete or no characters at or
1098 beyond START, hence deletion is a no-op. */
1102 /* Returns true if ST is empty, false otherwise. */
1104 ds_is_empty (const struct string *st)
1106 return ss_is_empty (st->ss);
1109 /* Returns the length of ST. */
1111 ds_length (const struct string *st)
1113 return ss_length (ds_ss (st));
1116 /* Returns the string data inside ST. */
1118 ds_data (const struct string *st)
1120 return ss_data (ds_ss (st));
1123 /* Returns a pointer to the null terminator ST.
1124 This might not be an actual null character unless ds_c_str() has
1125 been called since the last modification to ST. */
1127 ds_end (const struct string *st)
1129 return ss_end (ds_ss (st));
1132 /* Returns the character in position IDX in ST, as a value in the
1133 range of unsigned char. Returns EOF if IDX is out of the
1134 range of indexes for ST. */
1136 ds_at (const struct string *st, size_t idx)
1138 return ss_at (ds_ss (st), idx);
1141 /* Returns the first character in ST as a value in the range of
1142 unsigned char. Returns EOF if ST is the empty string. */
1144 ds_first (const struct string *st)
1146 return ss_first (ds_ss (st));
1149 /* Returns the last character in ST as a value in the range of
1150 unsigned char. Returns EOF if ST is the empty string. */
1152 ds_last (const struct string *st)
1154 return ss_last (ds_ss (st));
1157 /* Returns the number of consecutive characters at the beginning
1158 of ST that are in SKIP_SET. */
1160 ds_span (const struct string *st, struct substring skip_set)
1162 return ss_span (ds_ss (st), skip_set);
1165 /* Returns the number of consecutive characters at the beginning
1166 of ST that are not in STOP_SET. */
1168 ds_cspan (const struct string *st, struct substring stop_set)
1170 return ss_cspan (ds_ss (st), stop_set);
1173 /* Returns the position of the first occurrence of character C in
1174 ST at or after position OFS, or SIZE_MAX if there is no such
1177 ds_find_char (const struct string *st, char c)
1179 return ss_find_char (ds_ss (st), c);
1182 /* Compares A and B and returns a strcmp()-type comparison
1185 ds_compare (const struct string *a, const struct string *b)
1187 return ss_compare (ds_ss (a), ds_ss (b));
1190 /* Returns the position in ST that the character at P occupies.
1191 P must point within ST or one past its end. */
1193 ds_pointer_to_position (const struct string *st, const char *p)
1195 return ss_pointer_to_position (ds_ss (st), p);
1198 /* Allocates and returns a null-terminated string that contains
1201 ds_xstrdup (const struct string *st)
1203 return ss_xstrdup (ds_ss (st));
1206 /* Returns the allocation size of ST. */
1208 ds_capacity (const struct string *st)
1210 return st->capacity;
1213 /* Returns the value of ST as a null-terminated string. */
1215 ds_cstr (const struct string *st_)
1217 struct string *st = (struct string *) st_;
1218 if (st->ss.string == NULL)
1220 st->ss.string[st->ss.length] = '\0';
1221 return st->ss.string;
1224 /* Reads characters from STREAM and appends them to ST, stopping
1225 after MAX_LENGTH characters, after appending a newline, or
1226 after an I/O error or end of file was encountered, whichever
1227 comes first. Returns true if at least one character was added
1228 to ST, false if no characters were read before an I/O error or
1229 end of file (or if MAX_LENGTH was 0).
1231 This function accepts LF, CR LF, and CR sequences as new-line,
1232 and translates each of them to a single '\n' new-line
1235 ds_read_line (struct string *st, FILE *stream, size_t max_length)
1239 for (length = 0; length < max_length; length++)
1241 int c = getc (stream);
1254 ds_put_char (st, c);
1262 /* Removes a comment introduced by `#' from ST,
1263 ignoring occurrences inside quoted strings. */
1265 remove_comment (struct string *st)
1270 for (cp = ds_data (st); cp < ds_end (st); cp++)
1275 else if (*cp == '\\')
1278 else if (*cp == '\'' || *cp == '"')
1280 else if (*cp == '#')
1282 ds_truncate (st, cp - ds_cstr (st));
1287 /* Reads a line from STREAM into ST, then preprocesses as follows:
1289 - Splices lines terminated with `\'.
1291 - Deletes comments introduced by `#' outside of single or double
1294 - Deletes trailing white space.
1296 Returns true if a line was successfully read, false on
1297 failure. If LINE_NUMBER is non-null, then *LINE_NUMBER is
1298 incremented by the number of lines read. */
1300 ds_read_config_line (struct string *st, int *line_number, FILE *stream)
1305 if (!ds_read_line (st, stream, SIZE_MAX))
1308 ds_rtrim (st, ss_cstr (CC_SPACES));
1310 while (ds_chomp (st, '\\'));
1312 remove_comment (st);
1316 /* Attempts to read SIZE * CNT bytes from STREAM and append them
1318 Returns true if all the requested data was read, false otherwise. */
1320 ds_read_stream (struct string *st, size_t size, size_t cnt, FILE *stream)
1324 size_t try_bytes = xtimes (cnt, size);
1325 if (size_in_bounds_p (xsum (ds_length (st), try_bytes)))
1327 char *buffer = ds_put_uninit (st, try_bytes);
1328 size_t got_bytes = fread (buffer, 1, try_bytes, stream);
1329 ds_truncate (st, ds_length (st) - (try_bytes - got_bytes));
1330 return got_bytes == try_bytes;
1342 /* Concatenates S onto ST. */
1344 ds_put_cstr (struct string *st, const char *s)
1347 ds_put_substring (st, ss_cstr (s));
1350 /* Concatenates SS to ST. */
1352 ds_put_substring (struct string *st, struct substring ss)
1354 memcpy (ds_put_uninit (st, ss_length (ss)), ss_data (ss), ss_length (ss));
1357 /* Returns ds_end(ST) and THEN increases the length by INCR. */
1359 ds_put_uninit (struct string *st, size_t incr)
1362 ds_extend (st, ds_length (st) + incr);
1364 st->ss.length += incr;
1368 /* Formats FORMAT as a printf string and appends the result to ST. */
1370 ds_put_format (struct string *st, const char *format, ...)
1374 va_start (args, format);
1375 ds_put_vformat (st, format, args);
1379 /* Formats FORMAT as a printf string and appends the result to ST. */
1381 ds_put_vformat (struct string *st, const char *format, va_list args_)
1386 va_copy (args, args_);
1387 avail = st->ss.string != NULL ? st->capacity - st->ss.length + 1 : 0;
1388 needed = vsnprintf (st->ss.string + st->ss.length, avail, format, args);
1391 if (needed >= avail)
1393 va_copy (args, args_);
1394 vsprintf (ds_put_uninit (st, needed), format, args);
1399 /* Some old libc's returned -1 when the destination string
1401 while (needed == -1)
1403 ds_extend (st, (st->capacity + 1) * 2);
1404 avail = st->capacity - st->ss.length + 1;
1406 va_copy (args, args_);
1407 needed = vsnprintf (ds_end (st), avail, format, args);
1410 st->ss.length += needed;
1414 /* Appends character CH to ST. */
1416 ds_put_char (struct string *st, int ch)
1418 ds_put_uninit (st, 1)[0] = ch;
1421 /* Appends CNT copies of character CH to ST. */
1423 ds_put_char_multiple (struct string *st, int ch, size_t cnt)
1425 memset (ds_put_uninit (st, cnt), ch, cnt);
1429 /* If relocation has been enabled, replace ST,
1430 with its relocated version */
1432 ds_relocate (struct string *st)
1434 const char *orig = ds_cstr (st);
1435 const char *rel = relocate (orig);
1440 ds_put_cstr (st, rel);
1441 free ((char *) rel);