src/string.c

Sun, 22 Dec 2024 22:53:53 +0100

author
Mike Becker <universe@uap-core.de>
date
Sun, 22 Dec 2024 22:53:53 +0100
changeset 1049
415bf2ce6bab
parent 1048
12f38affefd5
child 1050
3df63e95921a
permissions
-rw-r--r--

fix cx_hash_key_cxstr() being a macro

issue #536

576
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
1 /*
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
3 *
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
4 * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
5 *
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
6 * Redistribution and use in source and binary forms, with or without
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
7 * modification, are permitted provided that the following conditions are met:
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
8 *
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
9 * 1. Redistributions of source code must retain the above copyright
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
10 * notice, this list of conditions and the following disclaimer.
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
11 *
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
12 * 2. Redistributions in binary form must reproduce the above copyright
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
13 * notice, this list of conditions and the following disclaimer in the
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
14 * documentation and/or other materials provided with the distribution.
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
15 *
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
17 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
19 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
20 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
26 * POSSIBILITY OF SUCH DAMAGE.
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
27 */
1048
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
28 #define CX_STR_IMPLEMENTATION
576
ba0c4ff6698e first proposal for the string header
Mike Becker <universe@uap-core.de>
parents:
diff changeset
29 #include "cx/string.h"
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
30
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
31 #include <string.h>
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
32 #include <stdarg.h>
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
33 #include <ctype.h>
1048
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
34 #include <assert.h>
1041
508dc8b32a17 fix missing errno.h include
Mike Becker <universe@uap-core.de>
parents: 1040
diff changeset
35 #include <errno.h>
1048
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
36 #include <limits.h>
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
37
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
38 #ifndef _WIN32
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
39
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
40 #include <strings.h> // for strncasecmp()
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
41
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
42 #endif // _WIN32
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
43
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
44 cxmutstr cx_mutstr(char *cstring) {
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
45 return (cxmutstr) {cstring, strlen(cstring)};
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
46 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
47
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
48 cxmutstr cx_mutstrn(
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
49 char *cstring,
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
50 size_t length
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
51 ) {
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
52 return (cxmutstr) {cstring, length};
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
53 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
54
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
55 cxstring cx_str(const char *cstring) {
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
56 return (cxstring) {cstring, strlen(cstring)};
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
57 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
58
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
59 cxstring cx_strn(
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
60 const char *cstring,
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
61 size_t length
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
62 ) {
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
63 return (cxstring) {cstring, length};
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
64 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
65
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
66 cxstring cx_strcast(cxmutstr str) {
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
67 return (cxstring) {str.ptr, str.length};
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
68 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
69
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
70 void cx_strfree(cxmutstr *str) {
985
68754c7de906 major refactoring of attributes
Mike Becker <universe@uap-core.de>
parents: 962
diff changeset
71 if (str == NULL) return;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
72 free(str->ptr);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
73 str->ptr = NULL;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
74 str->length = 0;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
75 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
76
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
77 void cx_strfree_a(
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
78 const CxAllocator *alloc,
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
79 cxmutstr *str
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
80 ) {
985
68754c7de906 major refactoring of attributes
Mike Becker <universe@uap-core.de>
parents: 962
diff changeset
81 if (str == NULL) return;
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
82 cxFree(alloc, str->ptr);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
83 str->ptr = NULL;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
84 str->length = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
85 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
86
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
87 size_t cx_strlen(
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
88 size_t count,
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
89 ...
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
90 ) {
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
91 if (count == 0) return 0;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
92
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
93 va_list ap;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
94 va_start(ap, count);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
95 size_t size = 0;
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
96 for (size_t i = 0; i < count; i++) {
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
97 cxstring str = va_arg(ap, cxstring);
1040
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
98 if (size > SIZE_MAX - str.length) errno = EOVERFLOW;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
99 size += str.length;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
100 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
101 va_end(ap);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
102
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
103 return size;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
104 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
105
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
106 cxmutstr cx_strcat_ma(
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
107 const CxAllocator *alloc,
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
108 cxmutstr str,
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
109 size_t count,
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
110 ...
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
111 ) {
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
112 if (count == 0) return str;
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
113
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
114 cxstring strings_stack[8];
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
115 cxstring *strings;
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
116 if (count > 8) {
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
117 strings = calloc(count, sizeof(cxstring));
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
118 if (strings == NULL) {
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
119 return (cxmutstr) {NULL, 0};
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
120 }
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
121 } else {
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
122 strings = strings_stack;
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
123 }
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
124
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
125 va_list ap;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
126 va_start(ap, count);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
127
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
128 // get all args and overall length
1040
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
129 bool overflow = false;
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
130 size_t slen = str.length;
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
131 for (size_t i = 0; i < count; i++) {
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
132 cxstring s = va_arg (ap, cxstring);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
133 strings[i] = s;
1040
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
134 if (slen > SIZE_MAX - str.length) overflow = true;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
135 slen += s.length;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
136 }
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
137 va_end(ap);
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
138
1040
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
139 // abort in case of overflow
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
140 if (overflow) {
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
141 errno = EOVERFLOW;
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
142 if (strings != strings_stack) {
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
143 free(strings);
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
144 }
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
145 return (cxmutstr) { NULL, 0 };
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
146 }
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
147
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
148 // reallocate or create new string
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
149 char *newstr;
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
150 if (str.ptr == NULL) {
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
151 newstr = cxMalloc(alloc, slen + 1);
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
152 } else {
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
153 newstr = cxRealloc(alloc, str.ptr, slen + 1);
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
154 }
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
155 if (newstr == NULL) {
1040
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
156 if (strings != strings_stack) {
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
157 free(strings);
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
158 }
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
159 return (cxmutstr) {NULL, 0};
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
160 }
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
161 str.ptr = newstr;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
162
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
163 // concatenate strings
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
164 size_t pos = str.length;
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
165 str.length = slen;
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
166 for (size_t i = 0; i < count; i++) {
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
167 cxstring s = strings[i];
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
168 memcpy(str.ptr + pos, s.ptr, s.length);
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
169 pos += s.length;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
170 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
171
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
172 // terminate string
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
173 str.ptr[str.length] = '\0';
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
174
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
175 // free temporary array
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
176 if (strings != strings_stack) {
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
177 free(strings);
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
178 }
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
179
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
180 return str;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
181 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
182
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
183 cxstring cx_strsubs(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
184 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
185 size_t start
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
186 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
187 return cx_strsubsl(string, start, string.length - start);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
188 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
189
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
190 cxmutstr cx_strsubs_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
191 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
192 size_t start
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
193 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
194 return cx_strsubsl_m(string, start, string.length - start);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
195 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
196
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
197 cxstring cx_strsubsl(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
198 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
199 size_t start,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
200 size_t length
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
201 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
202 if (start > string.length) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
203 return (cxstring) {NULL, 0};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
204 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
205
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
206 size_t rem_len = string.length - start;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
207 if (length > rem_len) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
208 length = rem_len;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
209 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
210
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
211 return (cxstring) {string.ptr + start, length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
212 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
213
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
214 cxmutstr cx_strsubsl_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
215 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
216 size_t start,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
217 size_t length
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
218 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
219 cxstring result = cx_strsubsl(cx_strcast(string), start, length);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
220 return (cxmutstr) {(char *) result.ptr, result.length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
221 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
222
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
223 cxstring cx_strchr(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
224 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
225 int chr
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
226 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
227 chr = 0xFF & chr;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
228 // TODO: improve by comparing multiple bytes at once
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
229 for (size_t i = 0; i < string.length; i++) {
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
230 if (string.ptr[i] == chr) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
231 return cx_strsubs(string, i);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
232 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
233 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
234 return (cxstring) {NULL, 0};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
235 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
236
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
237 cxmutstr cx_strchr_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
238 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
239 int chr
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
240 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
241 cxstring result = cx_strchr(cx_strcast(string), chr);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
242 return (cxmutstr) {(char *) result.ptr, result.length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
243 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
244
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
245 cxstring cx_strrchr(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
246 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
247 int chr
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
248 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
249 chr = 0xFF & chr;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
250 size_t i = string.length;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
251 while (i > 0) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
252 i--;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
253 // TODO: improve by comparing multiple bytes at once
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
254 if (string.ptr[i] == chr) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
255 return cx_strsubs(string, i);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
256 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
257 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
258 return (cxstring) {NULL, 0};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
259 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
260
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
261 cxmutstr cx_strrchr_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
262 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
263 int chr
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
264 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
265 cxstring result = cx_strrchr(cx_strcast(string), chr);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
266 return (cxmutstr) {(char *) result.ptr, result.length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
267 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
268
643
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
269 #ifndef CX_STRSTR_SBO_SIZE
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
270 #define CX_STRSTR_SBO_SIZE 512
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
271 #endif
926
8fdd8d78c14b fix several survivors of east-const and some missing consts
Mike Becker <universe@uap-core.de>
parents: 890
diff changeset
272 const unsigned cx_strstr_sbo_size = CX_STRSTR_SBO_SIZE;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
273
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
274 cxstring cx_strstr(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
275 cxstring haystack,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
276 cxstring needle
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
277 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
278 if (needle.length == 0) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
279 return haystack;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
280 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
281
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
282 // optimize for single-char needles
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
283 if (needle.length == 1) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
284 return cx_strchr(haystack, *needle.ptr);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
285 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
286
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
287 /*
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
288 * IMPORTANT:
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
289 * Our prefix table contains the prefix length PLUS ONE
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
290 * this is our decision, because we want to use the full range of size_t.
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
291 * The original algorithm needs a (-1) at one single place,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
292 * and we want to avoid that.
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
293 */
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
294
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
295 // local prefix table
643
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
296 size_t s_prefix_table[CX_STRSTR_SBO_SIZE];
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
297
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
298 // check needle length and use appropriate prefix table
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
299 // if the pattern exceeds static prefix table, allocate on the heap
643
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
300 bool useheap = needle.length >= CX_STRSTR_SBO_SIZE;
591
7df0bcaecffa fix over-optimization of strstr
Mike Becker <universe@uap-core.de>
parents: 590
diff changeset
301 register size_t *ptable = useheap ? calloc(needle.length + 1,
7df0bcaecffa fix over-optimization of strstr
Mike Becker <universe@uap-core.de>
parents: 590
diff changeset
302 sizeof(size_t)) : s_prefix_table;
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
303
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
304 // keep counter in registers
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
305 register size_t i, j;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
306
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
307 // fill prefix table
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
308 i = 0;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
309 j = 0;
591
7df0bcaecffa fix over-optimization of strstr
Mike Becker <universe@uap-core.de>
parents: 590
diff changeset
310 ptable[i] = j;
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
311 while (i < needle.length) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
312 while (j >= 1 && needle.ptr[j - 1] != needle.ptr[i]) {
591
7df0bcaecffa fix over-optimization of strstr
Mike Becker <universe@uap-core.de>
parents: 590
diff changeset
313 j = ptable[j - 1];
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
314 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
315 i++;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
316 j++;
591
7df0bcaecffa fix over-optimization of strstr
Mike Becker <universe@uap-core.de>
parents: 590
diff changeset
317 ptable[i] = j;
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
318 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
319
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
320 // search
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
321 cxstring result = {NULL, 0};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
322 i = 0;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
323 j = 1;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
324 while (i < haystack.length) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
325 while (j >= 1 && haystack.ptr[i] != needle.ptr[j - 1]) {
591
7df0bcaecffa fix over-optimization of strstr
Mike Becker <universe@uap-core.de>
parents: 590
diff changeset
326 j = ptable[j - 1];
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
327 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
328 i++;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
329 j++;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
330 if (j - 1 == needle.length) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
331 size_t start = i - needle.length;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
332 result.ptr = haystack.ptr + start;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
333 result.length = haystack.length - start;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
334 break;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
335 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
336 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
337
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
338 // if prefix table was allocated on the heap, free it
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
339 if (ptable != s_prefix_table) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
340 free(ptable);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
341 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
342
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
343 return result;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
344 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
345
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
346 cxmutstr cx_strstr_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
347 cxmutstr haystack,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
348 cxstring needle
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
349 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
350 cxstring result = cx_strstr(cx_strcast(haystack), needle);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
351 return (cxmutstr) {(char *) result.ptr, result.length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
352 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
353
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
354 size_t cx_strsplit(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
355 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
356 cxstring delim,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
357 size_t limit,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
358 cxstring *output
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
359 ) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
360 // special case: output limit is zero
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
361 if (limit == 0) return 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
362
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
363 // special case: delimiter is empty
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
364 if (delim.length == 0) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
365 output[0] = string;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
366 return 1;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
367 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
368
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
369 // special cases: delimiter is at least as large as the string
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
370 if (delim.length >= string.length) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
371 // exact match
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
372 if (cx_strcmp(string, delim) == 0) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
373 output[0] = cx_strn(string.ptr, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
374 output[1] = cx_strn(string.ptr + string.length, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
375 return 2;
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
376 } else {
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
377 // no match possible
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
378 output[0] = string;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
379 return 1;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
380 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
381 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
382
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
383 size_t n = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
384 cxstring curpos = string;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
385 while (1) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
386 ++n;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
387 cxstring match = cx_strstr(curpos, delim);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
388 if (match.length > 0) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
389 // is the limit reached?
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
390 if (n < limit) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
391 // copy the current string to the array
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
392 cxstring item = cx_strn(curpos.ptr, match.ptr - curpos.ptr);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
393 output[n - 1] = item;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
394 size_t processed = item.length + delim.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
395 curpos.ptr += processed;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
396 curpos.length -= processed;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
397 } else {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
398 // limit reached, copy the _full_ remaining string
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
399 output[n - 1] = curpos;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
400 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
401 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
402 } else {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
403 // no more matches, copy last string
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
404 output[n - 1] = curpos;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
405 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
406 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
407 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
408
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
409 return n;
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
410 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
411
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
412 size_t cx_strsplit_a(
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
413 const CxAllocator *allocator,
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
414 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
415 cxstring delim,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
416 size_t limit,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
417 cxstring **output
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
418 ) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
419 // find out how many splits we're going to make and allocate memory
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
420 size_t n = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
421 cxstring curpos = string;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
422 while (1) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
423 ++n;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
424 cxstring match = cx_strstr(curpos, delim);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
425 if (match.length > 0) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
426 // is the limit reached?
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
427 if (n < limit) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
428 size_t processed = match.ptr - curpos.ptr + delim.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
429 curpos.ptr += processed;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
430 curpos.length -= processed;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
431 } else {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
432 // limit reached
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
433 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
434 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
435 } else {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
436 // no more matches
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
437 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
438 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
439 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
440 *output = cxCalloc(allocator, n, sizeof(cxstring));
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
441 return cx_strsplit(string, delim, n, *output);
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
442 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
443
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
444 size_t cx_strsplit_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
445 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
446 cxstring delim,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
447 size_t limit,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
448 cxmutstr *output
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
449 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
450 return cx_strsplit(cx_strcast(string),
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
451 delim, limit, (cxstring *) output);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
452 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
453
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
454 size_t cx_strsplit_ma(
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
455 const CxAllocator *allocator,
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
456 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
457 cxstring delim,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
458 size_t limit,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
459 cxmutstr **output
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
460 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
461 return cx_strsplit_a(allocator, cx_strcast(string),
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
462 delim, limit, (cxstring **) output);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
463 }
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
464
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
465 int cx_strcmp(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
466 cxstring s1,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
467 cxstring s2
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
468 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
469 if (s1.length == s2.length) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
470 return memcmp(s1.ptr, s2.ptr, s1.length);
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
471 } else if (s1.length > s2.length) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
472 return 1;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
473 } else {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
474 return -1;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
475 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
476 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
477
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
478 int cx_strcasecmp(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
479 cxstring s1,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
480 cxstring s2
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
481 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
482 if (s1.length == s2.length) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
483 #ifdef _WIN32
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
484 return _strnicmp(s1.ptr, s2.ptr, s1.length);
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
485 #else
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
486 return strncasecmp(s1.ptr, s2.ptr, s1.length);
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
487 #endif
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
488 } else if (s1.length > s2.length) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
489 return 1;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
490 } else {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
491 return -1;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
492 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
493 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
494
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
495 int cx_strcmp_p(
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
496 const void *s1,
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
497 const void *s2
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
498 ) {
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
499 const cxstring *left = s1;
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
500 const cxstring *right = s2;
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
501 return cx_strcmp(*left, *right);
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
502 }
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
503
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
504 int cx_strcasecmp_p(
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
505 const void *s1,
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
506 const void *s2
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
507 ) {
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
508 const cxstring *left = s1;
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
509 const cxstring *right = s2;
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
510 return cx_strcasecmp(*left, *right);
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
511 }
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
512
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
513 cxmutstr cx_strdup_a(
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
514 const CxAllocator *allocator,
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
515 cxstring string
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
516 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
517 cxmutstr result = {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
518 cxMalloc(allocator, string.length + 1),
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
519 string.length
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
520 };
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
521 if (result.ptr == NULL) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
522 result.length = 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
523 return result;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
524 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
525 memcpy(result.ptr, string.ptr, string.length);
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
526 result.ptr[string.length] = '\0';
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
527 return result;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
528 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
529
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
530 cxstring cx_strtrim(cxstring string) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
531 cxstring result = string;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
532 // TODO: optimize by comparing multiple bytes at once
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
533 while (result.length > 0 && isspace(*result.ptr)) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
534 result.ptr++;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
535 result.length--;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
536 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
537 while (result.length > 0 && isspace(result.ptr[result.length - 1])) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
538 result.length--;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
539 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
540 return result;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
541 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
542
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
543 cxmutstr cx_strtrim_m(cxmutstr string) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
544 cxstring result = cx_strtrim(cx_strcast(string));
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
545 return (cxmutstr) {(char *) result.ptr, result.length};
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
546 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
547
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
548 bool cx_strprefix(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
549 cxstring string,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
550 cxstring prefix
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
551 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
552 if (string.length < prefix.length) return false;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
553 return memcmp(string.ptr, prefix.ptr, prefix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
554 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
555
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
556 bool cx_strsuffix(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
557 cxstring string,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
558 cxstring suffix
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
559 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
560 if (string.length < suffix.length) return false;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
561 return memcmp(string.ptr + string.length - suffix.length,
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
562 suffix.ptr, suffix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
563 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
564
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
565 bool cx_strcaseprefix(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
566 cxstring string,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
567 cxstring prefix
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
568 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
569 if (string.length < prefix.length) return false;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
570 #ifdef _WIN32
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
571 return _strnicmp(string.ptr, prefix.ptr, prefix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
572 #else
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
573 return strncasecmp(string.ptr, prefix.ptr, prefix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
574 #endif
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
575 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
576
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
577 bool cx_strcasesuffix(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
578 cxstring string,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
579 cxstring suffix
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
580 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
581 if (string.length < suffix.length) return false;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
582 #ifdef _WIN32
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
583 return _strnicmp(string.ptr+string.length-suffix.length,
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
584 suffix.ptr, suffix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
585 #else
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
586 return strncasecmp(string.ptr + string.length - suffix.length,
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
587 suffix.ptr, suffix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
588 #endif
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
589 }
582
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
590
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
591 void cx_strlower(cxmutstr string) {
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
592 for (size_t i = 0; i < string.length; i++) {
593
ea9b41b5ebbc explicitly cast int to char
Mike Becker <universe@uap-core.de>
parents: 591
diff changeset
593 string.ptr[i] = (char) tolower(string.ptr[i]);
582
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
594 }
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
595 }
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
596
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
597 void cx_strupper(cxmutstr string) {
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
598 for (size_t i = 0; i < string.length; i++) {
593
ea9b41b5ebbc explicitly cast int to char
Mike Becker <universe@uap-core.de>
parents: 591
diff changeset
599 string.ptr[i] = (char) toupper(string.ptr[i]);
582
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
600 }
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
601 }
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
602
643
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
603 #ifndef CX_STRREPLACE_INDEX_BUFFER_SIZE
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
604 #define CX_STRREPLACE_INDEX_BUFFER_SIZE 64
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
605 #endif
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
606
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
607 struct cx_strreplace_ibuf {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
608 size_t *buf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
609 struct cx_strreplace_ibuf *next;
590
02a56701a5cb fix missing zero-termination in strreplace
Mike Becker <universe@uap-core.de>
parents: 583
diff changeset
610 unsigned int len;
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
611 };
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
612
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
613 static void cx_strrepl_free_ibuf(struct cx_strreplace_ibuf *buf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
614 while (buf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
615 struct cx_strreplace_ibuf *next = buf->next;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
616 free(buf->buf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
617 free(buf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
618 buf = next;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
619 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
620 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
621
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
622 cxmutstr cx_strreplacen_a(
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
623 const CxAllocator *allocator,
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
624 cxstring str,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
625 cxstring pattern,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
626 cxstring replacement,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
627 size_t replmax
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
628 ) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
629
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
630 if (pattern.length == 0 || pattern.length > str.length || replmax == 0)
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
631 return cx_strdup_a(allocator, str);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
632
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
633 // Compute expected buffer length
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
634 size_t ibufmax = str.length / pattern.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
635 size_t ibuflen = replmax < ibufmax ? replmax : ibufmax;
643
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
636 if (ibuflen > CX_STRREPLACE_INDEX_BUFFER_SIZE) {
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
637 ibuflen = CX_STRREPLACE_INDEX_BUFFER_SIZE;
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
638 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
639
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
640 // Allocate first index buffer
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
641 struct cx_strreplace_ibuf *firstbuf, *curbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
642 firstbuf = curbuf = calloc(1, sizeof(struct cx_strreplace_ibuf));
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
643 if (!firstbuf) return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
644 firstbuf->buf = calloc(ibuflen, sizeof(size_t));
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
645 if (!firstbuf->buf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
646 free(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
647 return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
648 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
649
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
650 // Search occurrences
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
651 cxstring searchstr = str;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
652 size_t found = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
653 do {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
654 cxstring match = cx_strstr(searchstr, pattern);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
655 if (match.length > 0) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
656 // Allocate next buffer in chain, if required
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
657 if (curbuf->len == ibuflen) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
658 struct cx_strreplace_ibuf *nextbuf =
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
659 calloc(1, sizeof(struct cx_strreplace_ibuf));
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
660 if (!nextbuf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
661 cx_strrepl_free_ibuf(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
662 return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
663 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
664 nextbuf->buf = calloc(ibuflen, sizeof(size_t));
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
665 if (!nextbuf->buf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
666 free(nextbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
667 cx_strrepl_free_ibuf(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
668 return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
669 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
670 curbuf->next = nextbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
671 curbuf = nextbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
672 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
673
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
674 // Record match index
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
675 found++;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
676 size_t idx = match.ptr - str.ptr;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
677 curbuf->buf[curbuf->len++] = idx;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
678 searchstr.ptr = match.ptr + pattern.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
679 searchstr.length = str.length - idx - pattern.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
680 } else {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
681 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
682 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
683 } while (searchstr.length > 0 && found < replmax);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
684
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
685 // Allocate result string
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
686 cxmutstr result;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
687 {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
688 ssize_t adjlen = (ssize_t) replacement.length - (ssize_t) pattern.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
689 size_t rcount = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
690 curbuf = firstbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
691 do {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
692 rcount += curbuf->len;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
693 curbuf = curbuf->next;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
694 } while (curbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
695 result.length = str.length + rcount * adjlen;
590
02a56701a5cb fix missing zero-termination in strreplace
Mike Becker <universe@uap-core.de>
parents: 583
diff changeset
696 result.ptr = cxMalloc(allocator, result.length + 1);
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
697 if (!result.ptr) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
698 cx_strrepl_free_ibuf(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
699 return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
700 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
701 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
702
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
703 // Build result string
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
704 curbuf = firstbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
705 size_t srcidx = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
706 char *destptr = result.ptr;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
707 do {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
708 for (size_t i = 0; i < curbuf->len; i++) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
709 // Copy source part up to next match
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
710 size_t idx = curbuf->buf[i];
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
711 size_t srclen = idx - srcidx;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
712 if (srclen > 0) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
713 memcpy(destptr, str.ptr + srcidx, srclen);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
714 destptr += srclen;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
715 srcidx += srclen;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
716 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
717
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
718 // Copy the replacement and skip the source pattern
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
719 srcidx += pattern.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
720 memcpy(destptr, replacement.ptr, replacement.length);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
721 destptr += replacement.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
722 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
723 curbuf = curbuf->next;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
724 } while (curbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
725 memcpy(destptr, str.ptr + srcidx, str.length - srcidx);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
726
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
727 // Result is guaranteed to be zero-terminated
590
02a56701a5cb fix missing zero-termination in strreplace
Mike Becker <universe@uap-core.de>
parents: 583
diff changeset
728 result.ptr[result.length] = '\0';
02a56701a5cb fix missing zero-termination in strreplace
Mike Becker <universe@uap-core.de>
parents: 583
diff changeset
729
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
730 // Free index buffer
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
731 cx_strrepl_free_ibuf(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
732
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
733 return result;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
734 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
735
645
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
736 CxStrtokCtx cx_strtok(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
737 cxstring str,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
738 cxstring delim,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
739 size_t limit
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
740 ) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
741 CxStrtokCtx ctx;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
742 ctx.str = str;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
743 ctx.delim = delim;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
744 ctx.limit = limit;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
745 ctx.pos = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
746 ctx.next_pos = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
747 ctx.delim_pos = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
748 ctx.found = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
749 ctx.delim_more = NULL;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
750 ctx.delim_more_count = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
751 return ctx;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
752 }
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
753
645
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
754 CxStrtokCtx cx_strtok_m(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
755 cxmutstr str,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
756 cxstring delim,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
757 size_t limit
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
758 ) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
759 return cx_strtok(cx_strcast(str), delim, limit);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
760 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
761
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
762 bool cx_strtok_next(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
763 CxStrtokCtx *ctx,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
764 cxstring *token
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
765 ) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
766 // abortion criteria
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
767 if (ctx->found >= ctx->limit || ctx->delim_pos >= ctx->str.length) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
768 return false;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
769 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
770
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
771 // determine the search start
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
772 cxstring haystack = cx_strsubs(ctx->str, ctx->next_pos);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
773
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
774 // search the next delimiter
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
775 cxstring delim = cx_strstr(haystack, ctx->delim);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
776
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
777 // if found, make delim capture exactly the delimiter
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
778 if (delim.length > 0) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
779 delim.length = ctx->delim.length;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
780 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
781
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
782 // if more delimiters are specified, check them now
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
783 if (ctx->delim_more_count > 0) {
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
784 for (size_t i = 0; i < ctx->delim_more_count; i++) {
645
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
785 cxstring d = cx_strstr(haystack, ctx->delim_more[i]);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
786 if (d.length > 0 && (delim.length == 0 || d.ptr < delim.ptr)) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
787 delim.ptr = d.ptr;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
788 delim.length = ctx->delim_more[i].length;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
789 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
790 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
791 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
792
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
793 // store the token information and adjust the context
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
794 ctx->found++;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
795 ctx->pos = ctx->next_pos;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
796 token->ptr = &ctx->str.ptr[ctx->pos];
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
797 ctx->delim_pos = delim.length == 0 ?
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
798 ctx->str.length : (size_t) (delim.ptr - ctx->str.ptr);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
799 token->length = ctx->delim_pos - ctx->pos;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
800 ctx->next_pos = ctx->delim_pos + delim.length;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
801
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
802 return true;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
803 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
804
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
805 bool cx_strtok_next_m(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
806 CxStrtokCtx *ctx,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
807 cxmutstr *token
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
808 ) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
809 return cx_strtok_next(ctx, (cxstring *) token);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
810 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
811
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
812 void cx_strtok_delim(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
813 CxStrtokCtx *ctx,
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
814 const cxstring *delim,
645
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
815 size_t count
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
816 ) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
817 ctx->delim_more = delim;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
818 ctx->delim_more_count = count;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
819 }
1048
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
820
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
821 #define cx_strtoX_signed_impl(rtype, rmin, rmax) \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
822 int64_t result; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
823 if (cx_strtoi64_lc(str, &result, base, groupsep)) { \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
824 return -1; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
825 } \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
826 if (result < rmin || result > rmax) { \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
827 errno = ERANGE; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
828 return -1; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
829 } \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
830 *output = (rtype) result; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
831 return 0
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
832
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
833 int cx_strtos_lc(cxstring str, short *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
834 cx_strtoX_signed_impl(short, SHRT_MIN, SHRT_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
835 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
836
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
837 int cx_strtoi_lc(cxstring str, int *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
838 cx_strtoX_signed_impl(int, INT_MIN, INT_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
839 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
840
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
841 int cx_strtol_lc(cxstring str, long *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
842 cx_strtoX_signed_impl(long, LONG_MIN, LONG_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
843 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
844
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
845 int cx_strtoll_lc(cxstring str, long long *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
846 assert(sizeof(long long) == sizeof(int64_t)); // should be true on all platforms
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
847 return cx_strtoi64_lc(str, (int64_t*) output, base, groupsep);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
848 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
849
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
850 int cx_strtoi8_lc(cxstring str, int8_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
851 cx_strtoX_signed_impl(int8_t, INT8_MIN, INT8_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
852 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
853
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
854 int cx_strtoi16_lc(cxstring str, int16_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
855 cx_strtoX_signed_impl(int16_t, INT16_MIN, INT16_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
856 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
857
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
858 int cx_strtoi32_lc(cxstring str, int32_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
859 cx_strtoX_signed_impl(int32_t, INT32_MIN, INT32_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
860 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
861
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
862 int cx_strtoi64_lc(cxstring str, int64_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
863 // TODO: implement
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
864 return -1;
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
865 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
866
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
867 int cx_strtoz_lc(cxstring str, ssize_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
868 #if CX_WORDSIZE == 32
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
869 return cx_strtoi32_lc(str, output, base, groupsep);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
870 #else
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
871 return cx_strtoi64_lc(str, output, base, groupsep);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
872 #endif
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
873 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
874
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
875 #define cx_strtoX_unsigned_impl(rtype, rmax) \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
876 uint64_t result; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
877 if (cx_strtou64_lc(str, &result, base, groupsep)) { \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
878 return -1; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
879 } \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
880 if (result > rmax) { \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
881 errno = ERANGE; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
882 return -1; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
883 } \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
884 *output = (rtype) result; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
885 return 0
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
886
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
887 int cx_strtous_lc(cxstring str, unsigned short *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
888 cx_strtoX_unsigned_impl(unsigned short, USHRT_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
889 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
890
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
891 int cx_strtou_lc(cxstring str, unsigned int *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
892 cx_strtoX_unsigned_impl(unsigned int, UINT_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
893 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
894
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
895 int cx_strtoul_lc(cxstring str, unsigned long *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
896 cx_strtoX_unsigned_impl(unsigned long, ULONG_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
897 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
898
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
899 int cx_strtoull_lc(cxstring str, unsigned long long *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
900 assert(sizeof(unsigned long long) == sizeof(uint64_t)); // should be true on all platforms
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
901 return cx_strtou64_lc(str, (uint64_t*) output, base, groupsep);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
902 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
903
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
904 int cx_strtou8_lc(cxstring str, uint8_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
905 cx_strtoX_unsigned_impl(uint8_t, UINT8_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
906 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
907
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
908 int cx_strtou16_lc(cxstring str, uint16_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
909 cx_strtoX_unsigned_impl(uint16_t, UINT16_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
910 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
911
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
912 int cx_strtou32_lc(cxstring str, uint32_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
913 cx_strtoX_unsigned_impl(uint32_t, UINT32_MAX);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
914 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
915
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
916 int cx_strtou64_lc(cxstring str, uint64_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
917 // TODO: implement
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
918 return -1;
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
919 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
920
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
921 int cx_strtouz_lc(cxstring str, size_t *output, int base, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
922 #if CX_WORDSIZE == 32
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
923 return cx_strtou32_lc(str, output, base, groupsep);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
924 #else
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
925 return cx_strtou64_lc(str, output, base, groupsep);
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
926 #endif
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
927 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
928
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
929 int cx_strtof_lc(cxstring str, float *output, char decsep, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
930 // TODO: impl
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
931 return -1;
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
932 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
933
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
934 int cx_strtod_lc(cxstring str, double *output, char decsep, const char *groupsep) {
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
935 // TODO: impl
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
936 return -1;
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
937 }

mercurial