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/>. */
25 #include <libpspp/message.h>
26 #include <libpspp/pool.h>
32 /* Reverses the order of NBYTES bytes at address P, thus converting
33 between little- and big-endian byte orders. */
35 buf_reverse (char *p, size_t nbytes)
37 char *h = p, *t = &h[nbytes - 1];
49 /* Finds the last NEEDLE of length NEEDLE_LEN in a HAYSTACK of length
50 HAYSTACK_LEN. Returns a pointer to the needle found. */
52 buf_find_reverse (const char *haystack, size_t haystack_len,
53 const char *needle, size_t needle_len)
56 for (i = haystack_len - needle_len; i >= 0; i--)
57 if (!memcmp (needle, &haystack[i], needle_len))
58 return (char *) &haystack[i];
62 /* Compares the SIZE bytes in A to those in B, disregarding case,
63 and returns a strcmp()-type result. */
65 buf_compare_case (const char *a_, const char *b_, size_t size)
67 const unsigned char *a = (unsigned char *) a_;
68 const unsigned char *b = (unsigned char *) b_;
72 unsigned char ac = toupper (*a++);
73 unsigned char bc = toupper (*b++);
76 return ac > bc ? 1 : -1;
82 /* Compares A of length A_LEN to B of length B_LEN. The shorter
83 string is considered to be padded with spaces to the length of
86 buf_compare_rpad (const char *a, size_t a_len, const char *b, size_t b_len)
91 min_len = a_len < b_len ? a_len : b_len;
92 result = memcmp (a, b, min_len);
101 for (idx = min_len; idx < b_len; idx++)
103 return ' ' > b[idx] ? 1 : -1;
107 for (idx = min_len; idx < a_len; idx++)
109 return a[idx] > ' ' ? 1 : -1;
115 /* Compares strin A to string B. The shorter string is
116 considered to be padded with spaces to the length of the
119 str_compare_rpad (const char *a, const char *b)
121 return buf_compare_rpad (a, strlen (a), b, strlen (b));
124 /* Copies string SRC to buffer DST, of size DST_SIZE bytes.
125 DST is truncated to DST_SIZE bytes or padded on the right with
128 buf_copy_str_rpad (char *dst, size_t dst_size, const char *src)
130 size_t src_len = strlen (src);
131 if (src_len >= dst_size)
132 memcpy (dst, src, dst_size);
135 memcpy (dst, src, src_len);
136 memset (&dst[src_len], ' ', dst_size - src_len);
140 /* Copies string SRC to buffer DST, of size DST_SIZE bytes.
141 DST is truncated to DST_SIZE bytes or padded on the left with
144 buf_copy_str_lpad (char *dst, size_t dst_size, const char *src)
146 size_t src_len = strlen (src);
147 if (src_len >= dst_size)
148 memcpy (dst, src, dst_size);
151 size_t pad_cnt = dst_size - src_len;
152 memset (&dst[0], ' ', pad_cnt);
153 memcpy (dst + pad_cnt, src, src_len);
157 /* Copies buffer SRC, of SRC_SIZE bytes, to DST, of DST_SIZE bytes.
158 DST is truncated to DST_SIZE bytes or padded on the left with
161 buf_copy_lpad (char *dst, size_t dst_size,
162 const char *src, size_t src_size)
164 if (src_size >= dst_size)
165 memmove (dst, src, dst_size);
168 memset (dst, ' ', dst_size - src_size);
169 memmove (&dst[dst_size - src_size], src, src_size);
173 /* Copies buffer SRC, of SRC_SIZE bytes, to DST, of DST_SIZE bytes.
174 DST is truncated to DST_SIZE bytes or padded on the right with
177 buf_copy_rpad (char *dst, size_t dst_size,
178 const char *src, size_t src_size)
180 if (src_size >= dst_size)
181 memmove (dst, src, dst_size);
184 memmove (dst, src, src_size);
185 memset (&dst[src_size], ' ', dst_size - src_size);
189 /* Copies string SRC to string DST, which is in a buffer DST_SIZE
191 Truncates DST to DST_SIZE - 1 characters or right-pads with
192 spaces to DST_SIZE - 1 characters if necessary. */
194 str_copy_rpad (char *dst, size_t dst_size, const char *src)
196 size_t src_len = strlen (src);
197 if (src_len < dst_size - 1)
199 memcpy (dst, src, src_len);
200 memset (&dst[src_len], ' ', dst_size - 1 - src_len);
203 memcpy (dst, src, dst_size - 1);
204 dst[dst_size - 1] = 0;
207 /* Copies SRC to DST, which is in a buffer DST_SIZE bytes long.
208 Truncates DST to DST_SIZE - 1 characters, if necessary. */
210 str_copy_trunc (char *dst, size_t dst_size, const char *src)
212 size_t src_len = strlen (src);
213 assert (dst_size > 0);
214 if (src_len + 1 < dst_size)
215 memcpy (dst, src, src_len + 1);
218 memcpy (dst, src, dst_size - 1);
219 dst[dst_size - 1] = '\0';
223 /* Copies buffer SRC, of SRC_LEN bytes,
224 to DST, which is in a buffer DST_SIZE bytes long.
225 Truncates DST to DST_SIZE - 1 characters, if necessary. */
227 str_copy_buf_trunc (char *dst, size_t dst_size,
228 const char *src, size_t src_size)
231 assert (dst_size > 0);
233 dst_len = src_size < dst_size ? src_size : dst_size - 1;
234 memcpy (dst, src, dst_len);
238 /* Converts each character in S to uppercase. */
240 str_uppercase (char *s)
242 for (; *s != '\0'; s++)
243 *s = toupper ((unsigned char) *s);
246 /* Converts each character in S to lowercase. */
248 str_lowercase (char *s)
250 for (; *s != '\0'; s++)
251 *s = tolower ((unsigned char) *s);
254 /* Formats FORMAT into DST, as with sprintf(), and returns the
255 address of the terminating null written to DST. */
257 spprintf (char *dst, const char *format, ...)
262 va_start (args, format);
263 count = vsprintf (dst, format, args);
269 /* Sets the SIZE bytes starting at BLOCK to C,
270 and returns the byte following BLOCK. */
272 mempset (void *block, int c, size_t size)
274 memset (block, c, size);
275 return (char *) block + size;
280 /* Returns an empty substring. */
290 /* Returns a substring whose contents are the given C-style
293 ss_cstr (const char *cstr)
295 return ss_buffer (cstr, strlen (cstr));
298 /* Returns a substring whose contents are the CNT characters in
301 ss_buffer (const char *buffer, size_t cnt)
304 ss.string = (char *) buffer;
309 /* Returns a substring whose contents are the CNT characters
310 starting at the (0-based) position START in SS. */
312 ss_substr (struct substring ss, size_t start, size_t cnt)
314 if (start < ss.length)
315 return ss_buffer (ss.string + start, MIN (cnt, ss.length - start));
317 return ss_buffer (ss.string + ss.length, 0);
320 /* Returns a substring whose contents are the first CNT
323 ss_head (struct substring ss, size_t cnt)
325 return ss_buffer (ss.string, MIN (cnt, ss.length));
328 /* Returns a substring whose contents are the last CNT characters
331 ss_tail (struct substring ss, size_t cnt)
334 return ss_buffer (ss.string + (ss.length - cnt), cnt);
339 /* Makes a malloc()'d copy of the contents of OLD
340 and stores it in NEW. */
342 ss_alloc_substring (struct substring *new, struct substring old)
344 new->string = xmalloc (old.length);
345 new->length = old.length;
346 memcpy (new->string, old.string, old.length);
349 /* Allocates room for a CNT-character string in NEW. */
351 ss_alloc_uninit (struct substring *new, size_t cnt)
353 new->string = xmalloc (cnt);
357 /* Makes a pool_alloc_unaligned()'d copy of the contents of OLD
358 in POOL, and stores it in NEW. */
360 ss_alloc_substring_pool (struct substring *new, struct substring old,
363 new->string = pool_alloc_unaligned (pool, old.length);
364 new->length = old.length;
365 memcpy (new->string, old.string, old.length);
368 /* Allocates room for a CNT-character string in NEW in POOL. */
370 ss_alloc_uninit_pool (struct substring *new, size_t cnt, struct pool *pool)
372 new->string = pool_alloc_unaligned (pool, cnt);
376 /* Frees the string that SS points to. */
378 ss_dealloc (struct substring *ss)
383 /* Truncates SS to at most CNT characters in length. */
385 ss_truncate (struct substring *ss, size_t cnt)
387 if (ss->length > cnt)
391 /* Removes trailing characters in TRIM_SET from SS.
392 Returns number of characters removed. */
394 ss_rtrim (struct substring *ss, struct substring trim_set)
397 while (cnt < ss->length
398 && ss_find_char (trim_set,
399 ss->string[ss->length - cnt - 1]) != SIZE_MAX)
405 /* Removes leading characters in TRIM_SET from SS.
406 Returns number of characters removed. */
408 ss_ltrim (struct substring *ss, struct substring trim_set)
410 size_t cnt = ss_span (*ss, trim_set);
411 ss_advance (ss, cnt);
415 /* Trims leading and trailing characters in TRIM_SET from SS. */
417 ss_trim (struct substring *ss, struct substring trim_set)
419 ss_ltrim (ss, trim_set);
420 ss_rtrim (ss, trim_set);
423 /* If the last character in SS is C, removes it and returns true.
424 Otherwise, returns false without changing the string. */
426 ss_chomp (struct substring *ss, char c)
428 if (ss_last (*ss) == c)
437 /* Divides SS into tokens separated by any of the DELIMITERS.
438 Each call replaces TOKEN by the next token in SS, or by an
439 empty string if no tokens remain. Returns true if a token was
440 obtained, false otherwise.
442 Before the first call, initialize *SAVE_IDX to 0. Do not
443 modify *SAVE_IDX between calls.
445 SS divides into exactly one more tokens than it contains
446 delimiters. That is, a delimiter at the start or end of SS or
447 a pair of adjacent delimiters yields an empty token, and the
448 empty string contains a single token. */
450 ss_separate (struct substring ss, struct substring delimiters,
451 size_t *save_idx, struct substring *token)
453 if (*save_idx <= ss_length (ss))
455 struct substring tmp = ss_substr (ss, *save_idx, SIZE_MAX);
456 size_t length = ss_cspan (tmp, delimiters);
457 *token = ss_head (tmp, length);
458 *save_idx += length + 1;
463 *token = ss_empty ();
468 /* Divides SS into tokens separated by any of the DELIMITERS,
469 merging adjacent delimiters so that the empty string is never
470 produced as a token. Each call replaces TOKEN by the next
471 token in SS, or by an empty string if no tokens remain, and
472 then skips past the first delimiter following the token.
473 Returns true if a token was obtained, false otherwise.
475 Before the first call, initialize *SAVE_IDX to 0. Do not
476 modify *SAVE_IDX between calls. */
478 ss_tokenize (struct substring ss, struct substring delimiters,
479 size_t *save_idx, struct substring *token)
481 ss_advance (&ss, *save_idx);
482 *save_idx += ss_ltrim (&ss, delimiters);
483 ss_get_chars (&ss, ss_cspan (ss, delimiters), token);
484 *save_idx += ss_length (*token) + 1;
485 return ss_length (*token) > 0;
488 /* Removes the first CNT characters from SS. */
490 ss_advance (struct substring *ss, size_t cnt)
492 if (cnt > ss->length)
498 /* If the first character in SS is C, removes it and returns true.
499 Otherwise, returns false without changing the string. */
501 ss_match_char (struct substring *ss, char c)
503 if (ss_first (*ss) == c)
513 /* If SS begins with TARGET, removes it and returns true.
514 Otherwise, returns false without changing SS. */
516 ss_match_string (struct substring *ss, const struct substring target)
518 size_t length = ss_length (target);
519 if (ss_equals (ss_head (*ss, length), target))
521 ss_advance (ss, length);
528 /* Removes the first character from SS and returns it.
529 If SS is empty, returns EOF without modifying SS. */
531 ss_get_char (struct substring *ss)
533 int c = ss_first (*ss);
542 /* Stores the prefix of SS up to the first DELIMITER in OUT (if
543 any). Trims those same characters from SS. DELIMITER is
544 removed from SS but not made part of OUT. Returns true if
545 DELIMITER was found (and removed), false otherwise. */
547 ss_get_until (struct substring *ss, char delimiter, struct substring *out)
549 ss_get_chars (ss, ss_cspan (*ss, ss_buffer (&delimiter, 1)), out);
550 return ss_match_char (ss, delimiter);
553 /* Stores the first CNT characters in SS in OUT (or fewer, if SS
554 is shorter than CNT characters). Trims the same characters
555 from the beginning of SS. Returns CNT. */
557 ss_get_chars (struct substring *ss, size_t cnt, struct substring *out)
559 *out = ss_head (*ss, cnt);
560 ss_advance (ss, cnt);
564 /* Parses and removes an optionally signed decimal integer from
565 the beginning of SS. Returns 0 if an error occurred,
566 otherwise the number of characters removed from SS. Stores
567 the integer's value into *VALUE. */
569 ss_get_long (struct substring *ss, long *value)
574 length = ss_span (*ss, ss_cstr ("+-"));
575 length += ss_span (ss_substr (*ss, length, SIZE_MAX), ss_cstr (CC_DIGITS));
576 if (length > 0 && length < sizeof tmp)
580 memcpy (tmp, ss_data (*ss), length);
583 *value = strtol (tmp, &tail, 10);
584 if (tail - tmp == length)
586 ss_advance (ss, length);
594 /* Returns true if SS is empty (contains no characters),
597 ss_is_empty (struct substring ss)
599 return ss.length == 0;
602 /* Returns the number of characters in SS. */
604 ss_length (struct substring ss)
609 /* Returns a pointer to the characters in SS. */
611 ss_data (struct substring ss)
616 /* Returns a pointer just past the last character in SS. */
618 ss_end (struct substring ss)
620 return ss.string + ss.length;
623 /* Returns the character in position IDX in SS, as a value in the
624 range of unsigned char. Returns EOF if IDX is out of the
625 range of indexes for SS. */
627 ss_at (struct substring ss, size_t idx)
629 return idx < ss.length ? (unsigned char) ss.string[idx] : EOF;
632 /* Returns the first character in SS as a value in the range of
633 unsigned char. Returns EOF if SS is the empty string. */
635 ss_first (struct substring ss)
637 return ss_at (ss, 0);
640 /* Returns the last character in SS as a value in the range of
641 unsigned char. Returns EOF if SS is the empty string. */
643 ss_last (struct substring ss)
645 return ss.length > 0 ? (unsigned char) ss.string[ss.length - 1] : EOF;
648 /* Returns the number of contiguous characters at the beginning
649 of SS that are in SKIP_SET. */
651 ss_span (struct substring ss, struct substring skip_set)
654 for (i = 0; i < ss.length; i++)
655 if (ss_find_char (skip_set, ss.string[i]) == SIZE_MAX)
660 /* Returns the number of contiguous characters at the beginning
661 of SS that are not in SKIP_SET. */
663 ss_cspan (struct substring ss, struct substring stop_set)
666 for (i = 0; i < ss.length; i++)
667 if (ss_find_char (stop_set, ss.string[i]) != SIZE_MAX)
672 /* Returns the offset in SS of the first instance of C,
673 or SIZE_MAX if C does not occur in SS. */
675 ss_find_char (struct substring ss, char c)
677 const char *p = memchr (ss.string, c, ss.length);
678 return p != NULL ? p - ss.string : SIZE_MAX;
681 /* Compares A and B and returns a strcmp()-type comparison
684 ss_compare (struct substring a, struct substring b)
686 int retval = memcmp (a.string, b.string, MIN (a.length, b.length));
688 retval = a.length < b.length ? -1 : a.length > b.length;
692 /* Compares A and B case-insensitively and returns a
693 strcmp()-type comparison result. */
695 ss_compare_case (struct substring a, struct substring b)
697 int retval = memcasecmp (a.string, b.string, MIN (a.length, b.length));
699 retval = a.length < b.length ? -1 : a.length > b.length;
703 /* Compares A and B and returns true if their contents are
704 identical, false otherwise. */
706 ss_equals (struct substring a, struct substring b)
708 return a.length == b.length && !memcmp (a.string, b.string, a.length);
711 /* Compares A and B and returns true if their contents are
712 identical except possibly for case differences, false
715 ss_equals_case (struct substring a, struct substring b)
717 return a.length == b.length && !memcasecmp (a.string, b.string, a.length);
720 /* Returns the position in SS that the character at P occupies.
721 P must point within SS or one past its end. */
723 ss_pointer_to_position (struct substring ss, const char *p)
725 size_t pos = p - ss.string;
726 assert (pos <= ss.length);
730 /* Allocates and returns a null-terminated string that contains
733 ss_xstrdup (struct substring ss)
735 char *s = xmalloc (ss.length + 1);
736 memcpy (s, ss.string, ss.length);
741 /* Initializes ST as an empty string. */
743 ds_init_empty (struct string *st)
745 st->ss = ss_empty ();
749 /* Initializes ST with initial contents S. */
751 ds_init_string (struct string *st, const struct string *s)
753 ds_init_substring (st, ds_ss (s));
756 /* Initializes ST with initial contents SS. */
758 ds_init_substring (struct string *st, struct substring ss)
760 st->capacity = MAX (8, ss.length * 2);
761 st->ss.string = xmalloc (st->capacity + 1);
762 memcpy (st->ss.string, ss.string, ss.length);
763 st->ss.length = ss.length;
766 /* Initializes ST with initial contents S. */
768 ds_init_cstr (struct string *st, const char *s)
770 ds_init_substring (st, ss_cstr (s));
775 ds_destroy (struct string *st)
779 ss_dealloc (&st->ss);
780 st->ss.string = NULL;
786 /* Swaps the contents of strings A and B. */
788 ds_swap (struct string *a, struct string *b)
790 struct string tmp = *a;
795 /* Helper function for ds_register_pool. */
797 free_string (void *st_)
799 struct string *st = st_;
803 /* Arranges for ST to be destroyed automatically as part of
806 ds_register_pool (struct string *st, struct pool *pool)
808 pool_register (pool, free_string, st);
811 /* Cancels the arrangement for ST to be destroyed automatically
814 ds_unregister_pool (struct string *st, struct pool *pool)
816 pool_unregister (pool, st);
819 /* Copies SRC into DST.
820 DST and SRC may be the same string. */
822 ds_assign_string (struct string *dst, const struct string *src)
824 ds_assign_substring (dst, ds_ss (src));
827 /* Replaces DST by SS.
828 SS may be a substring of DST. */
830 ds_assign_substring (struct string *dst, struct substring ss)
832 dst->ss.length = ss.length;
833 ds_extend (dst, ss.length);
834 memmove (dst->ss.string, ss.string, ss.length);
837 /* Replaces DST by null-terminated string SRC. SRC may overlap
840 ds_assign_cstr (struct string *dst, const char *src)
842 ds_assign_substring (dst, ss_cstr (src));
845 /* Truncates ST to zero length. */
847 ds_clear (struct string *st)
852 /* Returns a substring that contains ST. */
854 ds_ss (const struct string *st)
859 /* Returns a substring that contains CNT characters from ST
860 starting at position START.
862 If START is greater than or equal to the length of ST, then
863 the substring will be the empty string. If START + CNT
864 exceeds the length of ST, then the substring will only be
865 ds_length(ST) - START characters long. */
867 ds_substr (const struct string *st, size_t start, size_t cnt)
869 return ss_substr (ds_ss (st), start, cnt);
872 /* Returns a substring that contains the first CNT characters in
873 ST. If CNT exceeds the length of ST, then the substring will
874 contain all of ST. */
876 ds_head (const struct string *st, size_t cnt)
878 return ss_head (ds_ss (st), cnt);
881 /* Returns a substring that contains the last CNT characters in
882 ST. If CNT exceeds the length of ST, then the substring will
883 contain all of ST. */
885 ds_tail (const struct string *st, size_t cnt)
887 return ss_tail (ds_ss (st), cnt);
890 /* Ensures that ST can hold at least MIN_CAPACITY characters plus a null
893 ds_extend (struct string *st, size_t min_capacity)
895 if (min_capacity > st->capacity)
898 if (st->capacity < min_capacity)
899 st->capacity = 2 * min_capacity;
901 st->ss.string = xrealloc (st->ss.string, st->capacity + 1);
905 /* Shrink ST to the minimum capacity need to contain its content. */
907 ds_shrink (struct string *st)
909 if (st->capacity != st->ss.length)
911 st->capacity = st->ss.length;
912 st->ss.string = xrealloc (st->ss.string, st->capacity + 1);
916 /* Truncates ST to at most LENGTH characters long. */
918 ds_truncate (struct string *st, size_t length)
920 ss_truncate (&st->ss, length);
923 /* Removes trailing characters in TRIM_SET from ST.
924 Returns number of characters removed. */
926 ds_rtrim (struct string *st, struct substring trim_set)
928 return ss_rtrim (&st->ss, trim_set);
931 /* Removes leading characters in TRIM_SET from ST.
932 Returns number of characters removed. */
934 ds_ltrim (struct string *st, struct substring trim_set)
936 size_t cnt = ds_span (st, trim_set);
938 ds_assign_substring (st, ds_substr (st, cnt, SIZE_MAX));
942 /* Trims leading and trailing characters in TRIM_SET from ST.
943 Returns number of charactesr removed. */
945 ds_trim (struct string *st, struct substring trim_set)
947 size_t cnt = ds_rtrim (st, trim_set);
948 return cnt + ds_ltrim (st, trim_set);
951 /* If the last character in ST is C, removes it and returns true.
952 Otherwise, returns false without modifying ST. */
954 ds_chomp (struct string *st, char c)
956 return ss_chomp (&st->ss, c);
959 /* Divides ST into tokens separated by any of the DELIMITERS.
960 Each call replaces TOKEN by the next token in ST, or by an
961 empty string if no tokens remain. Returns true if a token was
962 obtained, false otherwise.
964 Before the first call, initialize *SAVE_IDX to 0. Do not
965 modify *SAVE_IDX between calls.
967 ST divides into exactly one more tokens than it contains
968 delimiters. That is, a delimiter at the start or end of ST or
969 a pair of adjacent delimiters yields an empty token, and the
970 empty string contains a single token. */
972 ds_separate (const struct string *st, struct substring delimiters,
973 size_t *save_idx, struct substring *token)
975 return ss_separate (ds_ss (st), delimiters, save_idx, token);
978 /* Divides ST into tokens separated by any of the DELIMITERS,
979 merging adjacent delimiters so that the empty string is never
980 produced as a token. Each call replaces TOKEN by the next
981 token in ST, or by an empty string if no tokens remain.
982 Returns true if a token was obtained, false otherwise.
984 Before the first call, initialize *SAVE_IDX to 0. Do not
985 modify *SAVE_IDX between calls. */
987 ds_tokenize (const struct string *st, struct substring delimiters,
988 size_t *save_idx, struct substring *token)
990 return ss_tokenize (ds_ss (st), delimiters, save_idx, token);
993 /* Pad ST on the right with copies of PAD until ST is at least
994 LENGTH characters in size. If ST is initially LENGTH
995 characters or longer, this is a no-op. */
997 ds_rpad (struct string *st, size_t length, char pad)
999 if (length > st->ss.length)
1000 ds_put_char_multiple (st, pad, length - st->ss.length);
1003 /* Sets the length of ST to exactly NEW_LENGTH,
1004 either by truncating characters from the end,
1005 or by padding on the right with PAD. */
1007 ds_set_length (struct string *st, size_t new_length, char pad)
1009 if (st->ss.length < new_length)
1010 ds_rpad (st, new_length, pad);
1012 st->ss.length = new_length;
1015 /* Returns true if ST is empty, false otherwise. */
1017 ds_is_empty (const struct string *st)
1019 return ss_is_empty (st->ss);
1022 /* Returns the length of ST. */
1024 ds_length (const struct string *st)
1026 return ss_length (ds_ss (st));
1029 /* Returns the string data inside ST. */
1031 ds_data (const struct string *st)
1033 return ss_data (ds_ss (st));
1036 /* Returns a pointer to the null terminator ST.
1037 This might not be an actual null character unless ds_c_str() has
1038 been called since the last modification to ST. */
1040 ds_end (const struct string *st)
1042 return ss_end (ds_ss (st));
1045 /* Returns the character in position IDX in ST, as a value in the
1046 range of unsigned char. Returns EOF if IDX is out of the
1047 range of indexes for ST. */
1049 ds_at (const struct string *st, size_t idx)
1051 return ss_at (ds_ss (st), idx);
1054 /* Returns the first character in ST as a value in the range of
1055 unsigned char. Returns EOF if ST is the empty string. */
1057 ds_first (const struct string *st)
1059 return ss_first (ds_ss (st));
1062 /* Returns the last character in ST as a value in the range of
1063 unsigned char. Returns EOF if ST is the empty string. */
1065 ds_last (const struct string *st)
1067 return ss_last (ds_ss (st));
1070 /* Returns the number of consecutive characters at the beginning
1071 of ST that are in SKIP_SET. */
1073 ds_span (const struct string *st, struct substring skip_set)
1075 return ss_span (ds_ss (st), skip_set);
1078 /* Returns the number of consecutive characters at the beginning
1079 of ST that are not in STOP_SET. */
1081 ds_cspan (const struct string *st, struct substring stop_set)
1083 return ss_cspan (ds_ss (st), stop_set);
1086 /* Returns the position of the first occurrence of character C in
1087 ST at or after position OFS, or SIZE_MAX if there is no such
1090 ds_find_char (const struct string *st, char c)
1092 return ss_find_char (ds_ss (st), c);
1095 /* Compares A and B and returns a strcmp()-type comparison
1098 ds_compare (const struct string *a, const struct string *b)
1100 return ss_compare (ds_ss (a), ds_ss (b));
1103 /* Returns the position in ST that the character at P occupies.
1104 P must point within ST or one past its end. */
1106 ds_pointer_to_position (const struct string *st, const char *p)
1108 return ss_pointer_to_position (ds_ss (st), p);
1111 /* Allocates and returns a null-terminated string that contains
1114 ds_xstrdup (const struct string *st)
1116 return ss_xstrdup (ds_ss (st));
1119 /* Returns the allocation size of ST. */
1121 ds_capacity (const struct string *st)
1123 return st->capacity;
1126 /* Returns the value of ST as a null-terminated string. */
1128 ds_cstr (const struct string *st_)
1130 struct string *st = (struct string *) st_;
1131 if (st->ss.string == NULL)
1133 st->ss.string[st->ss.length] = '\0';
1134 return st->ss.string;
1137 /* Appends to ST a newline-terminated line read from STREAM.
1138 Newline is the last character of ST on return, unless an I/O error
1139 or end of file is encountered after reading some characters.
1140 Returns true if a line is successfully read, false if no characters at
1141 all were read before an I/O error or end of file was
1144 ds_read_line (struct string *st, FILE *stream)
1154 ds_put_char (st, c);
1164 /* Removes a comment introduced by `#' from ST,
1165 ignoring occurrences inside quoted strings. */
1167 remove_comment (struct string *st)
1172 for (cp = ds_data (st); cp < ds_end (st); cp++)
1177 else if (*cp == '\\')
1180 else if (*cp == '\'' || *cp == '"')
1182 else if (*cp == '#')
1184 ds_truncate (st, cp - ds_cstr (st));
1189 /* Reads a line from STREAM into ST, then preprocesses as follows:
1191 - Splices lines terminated with `\'.
1193 - Deletes comments introduced by `#' outside of single or double
1196 - Deletes trailing white space.
1198 Returns true if a line was successfully read, false on
1199 failure. If LINE_NUMBER is non-null, then *LINE_NUMBER is
1200 incremented by the number of lines read. */
1202 ds_read_config_line (struct string *st, int *line_number, FILE *stream)
1207 if (!ds_read_line (st, stream))
1210 ds_rtrim (st, ss_cstr (CC_SPACES));
1212 while (ds_chomp (st, '\\'));
1214 remove_comment (st);
1218 /* Attempts to read SIZE * CNT bytes from STREAM and append them
1220 Returns number of bytes actually read. */
1222 ds_read_stream (struct string *st, size_t size, size_t cnt, FILE *stream)
1226 size_t try_bytes = xtimes (cnt, size);
1227 if (size_in_bounds_p (xsum (ds_length (st), try_bytes)))
1229 char *buffer = ds_put_uninit (st, try_bytes);
1230 size_t got_bytes = fread (buffer, size, cnt, stream);
1231 ds_truncate (st, ds_length (st) - (try_bytes - got_bytes));
1238 /* Concatenates S onto ST. */
1240 ds_put_cstr (struct string *st, const char *s)
1243 ds_put_substring (st, ss_cstr (s));
1246 /* Concatenates SS to ST. */
1248 ds_put_substring (struct string *st, struct substring ss)
1250 memcpy (ds_put_uninit (st, ss_length (ss)), ss_data (ss), ss_length (ss));
1253 /* Returns ds_end(ST) and THEN increases the length by INCR. */
1255 ds_put_uninit (struct string *st, size_t incr)
1258 ds_extend (st, ds_length (st) + incr);
1260 st->ss.length += incr;
1264 /* Formats FORMAT as a printf string and appends the result to ST. */
1266 ds_put_format (struct string *st, const char *format, ...)
1270 va_start (args, format);
1271 ds_put_vformat (st, format, args);
1275 /* Formats FORMAT as a printf string and appends the result to ST. */
1277 ds_put_vformat (struct string *st, const char *format, va_list args_)
1282 va_copy (args, args_);
1283 avail = st->ss.string != NULL ? st->capacity - st->ss.length + 1 : 0;
1284 needed = vsnprintf (st->ss.string + st->ss.length, avail, format, args);
1287 if (needed >= avail)
1289 va_copy (args, args_);
1290 vsprintf (ds_put_uninit (st, needed), format, args);
1295 /* Some old libc's returned -1 when the destination string
1297 while (needed == -1)
1299 ds_extend (st, (st->capacity + 1) * 2);
1300 avail = st->capacity - st->ss.length + 1;
1302 va_copy (args, args_);
1303 needed = vsnprintf (ds_end (st), avail, format, args);
1306 st->ss.length += needed;
1310 /* Appends character CH to ST. */
1312 ds_put_char (struct string *st, int ch)
1314 ds_put_uninit (st, 1)[0] = ch;
1317 /* Appends CNT copies of character CH to ST. */
1319 ds_put_char_multiple (struct string *st, int ch, size_t cnt)
1321 memset (ds_put_uninit (st, cnt), ch, cnt);