src/string.c

Mon, 23 Dec 2024 00:33:27 +0100

author
Mike Becker <universe@uap-core.de>
date
Mon, 23 Dec 2024 00:33:27 +0100
changeset 1051
7d17bd1103d7
parent 1050
3df63e95921a
child 1052
e997862a57d8
permissions
-rw-r--r--

fix another missing free() in json tests

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 void cx_strfree(cxmutstr *str) {
985
68754c7de906 major refactoring of attributes
Mike Becker <universe@uap-core.de>
parents: 962
diff changeset
67 if (str == NULL) return;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
68 free(str->ptr);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
69 str->ptr = NULL;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
70 str->length = 0;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
71 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
72
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
73 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
74 const CxAllocator *alloc,
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
75 cxmutstr *str
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
76 ) {
985
68754c7de906 major refactoring of attributes
Mike Becker <universe@uap-core.de>
parents: 962
diff changeset
77 if (str == NULL) return;
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
78 cxFree(alloc, str->ptr);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
79 str->ptr = NULL;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
80 str->length = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
81 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
82
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
83 size_t cx_strlen(
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
84 size_t count,
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
85 ...
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
86 ) {
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
87 if (count == 0) return 0;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
88
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
89 va_list ap;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
90 va_start(ap, count);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
91 size_t size = 0;
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
92 for (size_t i = 0; i < count; i++) {
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
93 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
94 if (size > SIZE_MAX - str.length) errno = EOVERFLOW;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
95 size += str.length;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
96 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
97 va_end(ap);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
98
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
99 return size;
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
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
102 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
103 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
104 cxmutstr str,
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
105 size_t count,
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
106 ...
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
107 ) {
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 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
109
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
110 cxstring strings_stack[8];
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
111 cxstring *strings;
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
112 if (count > 8) {
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
113 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
114 if (strings == NULL) {
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
115 return (cxmutstr) {NULL, 0};
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
116 }
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
117 } else {
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
118 strings = strings_stack;
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
119 }
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
120
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
121 va_list ap;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
122 va_start(ap, count);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
123
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
124 // 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
125 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
126 size_t slen = str.length;
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
127 for (size_t i = 0; i < count; i++) {
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
128 cxstring s = va_arg (ap, cxstring);
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
129 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
130 if (slen > SIZE_MAX - str.length) overflow = true;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
131 slen += s.length;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
132 }
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
133 va_end(ap);
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
134
1040
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
135 // 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
136 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
137 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
138 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
139 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
140 }
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
141 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
142 }
1ecf4dbbc60c add some more overflow treatment and make sure to set errno properly
Mike Becker <universe@uap-core.de>
parents: 1001
diff changeset
143
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
144 // 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
145 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
146 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
147 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
148 } else {
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
149 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
150 }
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
151 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
152 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
153 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
154 }
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
155 return (cxmutstr) {NULL, 0};
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
156 }
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
157 str.ptr = newstr;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
158
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
159 // 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
160 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
161 str.length = slen;
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
162 for (size_t i = 0; i < count; i++) {
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
163 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
164 memcpy(str.ptr + pos, s.ptr, s.length);
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
165 pos += s.length;
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
166 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
167
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
168 // 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
169 str.ptr[str.length] = '\0';
579
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 // free temporary array
1001
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
172 if (strings != strings_stack) {
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
173 free(strings);
5c9ec5a0a4ef change cx_strcat variants to allow handling of ENOMEM
Mike Becker <universe@uap-core.de>
parents: 985
diff changeset
174 }
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
175
697
ebdce4bf262b add cx_strcat_m() and cx_strcat_ma() for in-place concatenation
Mike Becker <universe@uap-core.de>
parents: 693
diff changeset
176 return str;
579
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
177 }
bbc46dcd5255 start implementing string functions
Mike Becker <universe@uap-core.de>
parents: 576
diff changeset
178
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
179 cxstring cx_strsubs(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
180 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
181 size_t start
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
182 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
183 return cx_strsubsl(string, start, string.length - start);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
184 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
185
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
186 cxmutstr cx_strsubs_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
187 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
188 size_t start
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 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
191 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
192
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
193 cxstring cx_strsubsl(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
194 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
195 size_t start,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
196 size_t length
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
197 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
198 if (start > string.length) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
199 return (cxstring) {NULL, 0};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
200 }
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 size_t rem_len = string.length - start;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
203 if (length > rem_len) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
204 length = rem_len;
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
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
207 return (cxstring) {string.ptr + start, length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
208 }
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 cxmutstr cx_strsubsl_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
211 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
212 size_t start,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
213 size_t length
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
214 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
215 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
216 return (cxmutstr) {(char *) result.ptr, result.length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
217 }
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 cx_strchr(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
220 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
221 int chr
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 chr = 0xFF & chr;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
224 // 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
225 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
226 if (string.ptr[i] == chr) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
227 return cx_strsubs(string, i);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
228 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
229 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
230 return (cxstring) {NULL, 0};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
231 }
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 cxmutstr cx_strchr_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
234 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
235 int chr
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 cxstring result = cx_strchr(cx_strcast(string), chr);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
238 return (cxmutstr) {(char *) result.ptr, result.length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
239 }
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 cx_strrchr(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
242 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
243 int chr
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 chr = 0xFF & chr;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
246 size_t i = string.length;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
247 while (i > 0) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
248 i--;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
249 // TODO: improve by comparing multiple bytes at once
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
250 if (string.ptr[i] == chr) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
251 return cx_strsubs(string, i);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
252 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
253 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
254 return (cxstring) {NULL, 0};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
255 }
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 cxmutstr cx_strrchr_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
258 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
259 int chr
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 cxstring result = cx_strrchr(cx_strcast(string), chr);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
262 return (cxmutstr) {(char *) result.ptr, result.length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
263 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
264
643
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
265 #ifndef CX_STRSTR_SBO_SIZE
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
266 #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
267 #endif
926
8fdd8d78c14b fix several survivors of east-const and some missing consts
Mike Becker <universe@uap-core.de>
parents: 890
diff changeset
268 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
269
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
270 cxstring cx_strstr(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
271 cxstring haystack,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
272 cxstring needle
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
273 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
274 if (needle.length == 0) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
275 return haystack;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
276 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
277
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
278 // optimize for single-char needles
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
279 if (needle.length == 1) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
280 return cx_strchr(haystack, *needle.ptr);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
281 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
282
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
283 /*
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
284 * IMPORTANT:
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
285 * 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
286 * 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
287 * 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
288 * and we want to avoid that.
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
289 */
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
290
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
291 // local prefix table
643
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
292 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
293
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
294 // 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
295 // 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
296 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
297 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
298 sizeof(size_t)) : s_prefix_table;
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
299
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
300 // keep counter in registers
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
301 register size_t i, j;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
302
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
303 // fill prefix table
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
304 i = 0;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
305 j = 0;
591
7df0bcaecffa fix over-optimization of strstr
Mike Becker <universe@uap-core.de>
parents: 590
diff changeset
306 ptable[i] = j;
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
307 while (i < needle.length) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
308 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
309 j = ptable[j - 1];
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
310 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
311 i++;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
312 j++;
591
7df0bcaecffa fix over-optimization of strstr
Mike Becker <universe@uap-core.de>
parents: 590
diff changeset
313 ptable[i] = j;
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
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
316 // search
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
317 cxstring result = {NULL, 0};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
318 i = 0;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
319 j = 1;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
320 while (i < haystack.length) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
321 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
322 j = ptable[j - 1];
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
323 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
324 i++;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
325 j++;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
326 if (j - 1 == needle.length) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
327 size_t start = i - needle.length;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
328 result.ptr = haystack.ptr + start;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
329 result.length = haystack.length - start;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
330 break;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
331 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
332 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
333
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
334 // 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
335 if (ptable != s_prefix_table) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
336 free(ptable);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
337 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
338
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
339 return result;
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
340 }
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 cxmutstr cx_strstr_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
343 cxmutstr haystack,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
344 cxstring needle
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 cxstring result = cx_strstr(cx_strcast(haystack), needle);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
347 return (cxmutstr) {(char *) result.ptr, result.length};
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
348 }
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 size_t cx_strsplit(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
351 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
352 cxstring delim,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
353 size_t limit,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
354 cxstring *output
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
355 ) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
356 // 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
357 if (limit == 0) return 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
358
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
359 // special case: delimiter is empty
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
360 if (delim.length == 0) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
361 output[0] = string;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
362 return 1;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
363 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
364
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
365 // 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
366 if (delim.length >= string.length) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
367 // exact match
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
368 if (cx_strcmp(string, delim) == 0) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
369 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
370 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
371 return 2;
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
372 } else {
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
373 // no match possible
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
374 output[0] = string;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
375 return 1;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
376 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
377 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
378
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
379 size_t n = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
380 cxstring curpos = string;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
381 while (1) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
382 ++n;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
383 cxstring match = cx_strstr(curpos, delim);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
384 if (match.length > 0) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
385 // is the limit reached?
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
386 if (n < limit) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
387 // 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
388 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
389 output[n - 1] = item;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
390 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
391 curpos.ptr += processed;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
392 curpos.length -= processed;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
393 } else {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
394 // 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
395 output[n - 1] = curpos;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
396 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
397 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
398 } else {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
399 // 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
400 output[n - 1] = curpos;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
401 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
402 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
403 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
404
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
405 return n;
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
406 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
407
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
408 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
409 const CxAllocator *allocator,
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
410 cxstring string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
411 cxstring delim,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
412 size_t limit,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
413 cxstring **output
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
414 ) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
415 // 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
416 size_t n = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
417 cxstring curpos = string;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
418 while (1) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
419 ++n;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
420 cxstring match = cx_strstr(curpos, delim);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
421 if (match.length > 0) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
422 // is the limit reached?
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
423 if (n < limit) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
424 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
425 curpos.ptr += processed;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
426 curpos.length -= processed;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
427 } else {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
428 // limit reached
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
429 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
430 }
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 // no more matches
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 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
436 *output = cxCalloc(allocator, n, sizeof(cxstring));
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
437 return cx_strsplit(string, delim, n, *output);
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
438 }
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
439
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
440 size_t cx_strsplit_m(
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
441 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
442 cxstring delim,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
443 size_t limit,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
444 cxmutstr *output
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
445 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
446 return cx_strsplit(cx_strcast(string),
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
447 delim, limit, (cxstring *) output);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
448 }
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 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
451 const CxAllocator *allocator,
580
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
452 cxmutstr string,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
453 cxstring delim,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
454 size_t limit,
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
455 cxmutstr **output
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
456 ) {
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
457 return cx_strsplit_a(allocator, cx_strcast(string),
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
458 delim, limit, (cxstring **) output);
aac47db8da0b more implementations of string functions
Mike Becker <universe@uap-core.de>
parents: 579
diff changeset
459 }
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
460
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
461 int cx_strcmp(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
462 cxstring s1,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
463 cxstring s2
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
464 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
465 if (s1.length == s2.length) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
466 return memcmp(s1.ptr, s2.ptr, s1.length);
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
467 } else if (s1.length > s2.length) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
468 return 1;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
469 } else {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
470 return -1;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
471 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
472 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
473
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
474 int cx_strcasecmp(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
475 cxstring s1,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
476 cxstring s2
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
477 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
478 if (s1.length == s2.length) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
479 #ifdef _WIN32
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
480 return _strnicmp(s1.ptr, s2.ptr, s1.length);
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
481 #else
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
482 return strncasecmp(s1.ptr, s2.ptr, s1.length);
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
483 #endif
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
484 } else if (s1.length > s2.length) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
485 return 1;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
486 } else {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
487 return -1;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
488 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
489 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
490
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
491 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
492 const void *s1,
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
493 const void *s2
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
494 ) {
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
495 const cxstring *left = s1;
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
496 const cxstring *right = s2;
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
497 return cx_strcmp(*left, *right);
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
498 }
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
499
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
500 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
501 const void *s1,
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
502 const void *s2
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
503 ) {
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
504 const cxstring *left = s1;
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
505 const cxstring *right = s2;
657
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
506 return cx_strcasecmp(*left, *right);
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
507 }
3eeadf666d6b add CxListComparator compatible string compare functions
Mike Becker <universe@uap-core.de>
parents: 645
diff changeset
508
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
509 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
510 const CxAllocator *allocator,
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
511 cxstring string
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
512 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
513 cxmutstr result = {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
514 cxMalloc(allocator, string.length + 1),
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
515 string.length
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
516 };
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
517 if (result.ptr == NULL) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
518 result.length = 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
519 return result;
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 memcpy(result.ptr, string.ptr, string.length);
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
522 result.ptr[string.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
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
526 cxstring cx_strtrim(cxstring string) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
527 cxstring result = string;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
528 // TODO: optimize by comparing multiple bytes at once
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
529 while (result.length > 0 && isspace(*result.ptr)) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
530 result.ptr++;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
531 result.length--;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
532 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
533 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
534 result.length--;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
535 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
536 return result;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
537 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
538
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
539 cxmutstr cx_strtrim_m(cxmutstr string) {
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
540 cxstring result = cx_strtrim(cx_strcast(string));
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
541 return (cxmutstr) {(char *) result.ptr, result.length};
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
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
544 bool cx_strprefix(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
545 cxstring string,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
546 cxstring prefix
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
547 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
548 if (string.length < prefix.length) return false;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
549 return memcmp(string.ptr, prefix.ptr, prefix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
550 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
551
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
552 bool cx_strsuffix(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
553 cxstring string,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
554 cxstring suffix
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
555 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
556 if (string.length < suffix.length) return false;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
557 return memcmp(string.ptr + string.length - suffix.length,
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
558 suffix.ptr, suffix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
559 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
560
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
561 bool cx_strcaseprefix(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
562 cxstring string,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
563 cxstring prefix
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
564 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
565 if (string.length < prefix.length) return false;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
566 #ifdef _WIN32
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
567 return _strnicmp(string.ptr, prefix.ptr, prefix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
568 #else
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
569 return strncasecmp(string.ptr, prefix.ptr, prefix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
570 #endif
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
571 }
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
572
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
573 bool cx_strcasesuffix(
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
574 cxstring string,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
575 cxstring suffix
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
576 ) {
581
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
577 if (string.length < suffix.length) return false;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
578 #ifdef _WIN32
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
579 return _strnicmp(string.ptr+string.length-suffix.length,
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
580 suffix.ptr, suffix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
581 #else
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
582 return strncasecmp(string.ptr + string.length - suffix.length,
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
583 suffix.ptr, suffix.length) == 0;
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
584 #endif
c067394737ca implement more string functions
Mike Becker <universe@uap-core.de>
parents: 580
diff changeset
585 }
582
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
586
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
587 void cx_strlower(cxmutstr string) {
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
588 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
589 string.ptr[i] = (char) tolower(string.ptr[i]);
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 }
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
592
96fa7fa6af4f implement strupper and strlower
Mike Becker <universe@uap-core.de>
parents: 581
diff changeset
593 void cx_strupper(cxmutstr string) {
962
cd418898af5c remove cx_for_n() macro - fixes #467
Mike Becker <universe@uap-core.de>
parents: 926
diff changeset
594 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
595 string.ptr[i] = (char) toupper(string.ptr[i]);
582
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 }
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
598
643
5700ba9154ab #228 make buffer sizes adjustable at compile time
Mike Becker <universe@uap-core.de>
parents: 628
diff changeset
599 #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
600 #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
601 #endif
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
602
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
603 struct cx_strreplace_ibuf {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
604 size_t *buf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
605 struct cx_strreplace_ibuf *next;
590
02a56701a5cb fix missing zero-termination in strreplace
Mike Becker <universe@uap-core.de>
parents: 583
diff changeset
606 unsigned int len;
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
607 };
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
608
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
609 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
610 while (buf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
611 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
612 free(buf->buf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
613 free(buf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
614 buf = next;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
615 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
616 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
617
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
618 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
619 const CxAllocator *allocator,
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
620 cxstring str,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
621 cxstring pattern,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
622 cxstring replacement,
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
623 size_t replmax
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
624 ) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
625
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
626 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
627 return cx_strdup_a(allocator, str);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
628
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
629 // Compute expected buffer length
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
630 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
631 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
632 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
633 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
634 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
635
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
636 // Allocate first index buffer
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
637 struct cx_strreplace_ibuf *firstbuf, *curbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
638 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
639 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
640 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
641 if (!firstbuf->buf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
642 free(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
643 return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
644 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
645
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
646 // Search occurrences
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
647 cxstring searchstr = str;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
648 size_t found = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
649 do {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
650 cxstring match = cx_strstr(searchstr, pattern);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
651 if (match.length > 0) {
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
652 // 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
653 if (curbuf->len == ibuflen) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
654 struct cx_strreplace_ibuf *nextbuf =
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
655 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
656 if (!nextbuf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
657 cx_strrepl_free_ibuf(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
658 return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
659 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
660 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
661 if (!nextbuf->buf) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
662 free(nextbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
663 cx_strrepl_free_ibuf(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
664 return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
665 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
666 curbuf->next = nextbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
667 curbuf = nextbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
668 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
669
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
670 // Record match index
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
671 found++;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
672 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
673 curbuf->buf[curbuf->len++] = idx;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
674 searchstr.ptr = match.ptr + pattern.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
675 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
676 } else {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
677 break;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
678 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
679 } while (searchstr.length > 0 && found < replmax);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
680
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
681 // Allocate result string
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
682 cxmutstr result;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
683 {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
684 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
685 size_t rcount = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
686 curbuf = firstbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
687 do {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
688 rcount += curbuf->len;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
689 curbuf = curbuf->next;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
690 } while (curbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
691 result.length = str.length + rcount * adjlen;
590
02a56701a5cb fix missing zero-termination in strreplace
Mike Becker <universe@uap-core.de>
parents: 583
diff changeset
692 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
693 if (!result.ptr) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
694 cx_strrepl_free_ibuf(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
695 return cx_mutstrn(NULL, 0);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
696 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
697 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
698
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
699 // Build result string
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
700 curbuf = firstbuf;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
701 size_t srcidx = 0;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
702 char *destptr = result.ptr;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
703 do {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
704 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
705 // 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
706 size_t idx = curbuf->buf[i];
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
707 size_t srclen = idx - srcidx;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
708 if (srclen > 0) {
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
709 memcpy(destptr, str.ptr + srcidx, srclen);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
710 destptr += srclen;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
711 srcidx += srclen;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
712 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
713
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
714 // 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
715 srcidx += pattern.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
716 memcpy(destptr, replacement.ptr, replacement.length);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
717 destptr += replacement.length;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
718 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
719 curbuf = curbuf->next;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
720 } while (curbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
721 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
722
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
723 // 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
724 result.ptr[result.length] = '\0';
02a56701a5cb fix missing zero-termination in strreplace
Mike Becker <universe@uap-core.de>
parents: 583
diff changeset
725
628
1e2be40f0cb5 use //-style single line comments everywhere
Mike Becker <universe@uap-core.de>
parents: 593
diff changeset
726 // Free index buffer
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
727 cx_strrepl_free_ibuf(firstbuf);
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
728
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
729 return result;
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
730 }
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
731
645
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
732 CxStrtokCtx cx_strtok(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
733 cxstring str,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
734 cxstring delim,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
735 size_t limit
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
736 ) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
737 CxStrtokCtx ctx;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
738 ctx.str = str;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
739 ctx.delim = delim;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
740 ctx.limit = limit;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
741 ctx.pos = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
742 ctx.next_pos = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
743 ctx.delim_pos = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
744 ctx.found = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
745 ctx.delim_more = NULL;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
746 ctx.delim_more_count = 0;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
747 return ctx;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
748 }
583
0f3c9662f9b5 add tests and missing implementations for strings
Mike Becker <universe@uap-core.de>
parents: 582
diff changeset
749
645
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
750 CxStrtokCtx cx_strtok_m(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
751 cxmutstr str,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
752 cxstring delim,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
753 size_t limit
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
754 ) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
755 return cx_strtok(cx_strcast(str), delim, limit);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
756 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
757
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
758 bool cx_strtok_next(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
759 CxStrtokCtx *ctx,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
760 cxstring *token
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 // abortion criteria
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
763 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
764 return false;
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
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
767 // determine the search start
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
768 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
769
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
770 // search the next delimiter
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
771 cxstring delim = cx_strstr(haystack, ctx->delim);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
772
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
773 // if found, make delim capture exactly the delimiter
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
774 if (delim.length > 0) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
775 delim.length = ctx->delim.length;
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
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
778 // if more delimiters are specified, check them now
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
779 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
780 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
781 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
782 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
783 delim.ptr = d.ptr;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
784 delim.length = ctx->delim_more[i].length;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
785 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
786 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
787 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
788
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
789 // store the token information and adjust the context
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
790 ctx->found++;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
791 ctx->pos = ctx->next_pos;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
792 token->ptr = &ctx->str.ptr[ctx->pos];
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
793 ctx->delim_pos = delim.length == 0 ?
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
794 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
795 token->length = ctx->delim_pos - ctx->pos;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
796 ctx->next_pos = ctx->delim_pos + delim.length;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
797
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
798 return true;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
799 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
800
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
801 bool cx_strtok_next_m(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
802 CxStrtokCtx *ctx,
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
803 cxmutstr *token
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 return cx_strtok_next(ctx, (cxstring *) token);
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
806 }
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
807
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
808 void cx_strtok_delim(
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
809 CxStrtokCtx *ctx,
890
54565fd74e74 move all const keywords to the west - fixes #426
Mike Becker <universe@uap-core.de>
parents: 806
diff changeset
810 const cxstring *delim,
645
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
811 size_t count
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
812 ) {
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
813 ctx->delim_more = delim;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
814 ctx->delim_more_count = count;
ec50abb285ad add strtok API - fixes #220
Mike Becker <universe@uap-core.de>
parents: 643
diff changeset
815 }
1048
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
816
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
817 #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
818 int64_t result; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
819 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
820 return -1; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
821 } \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
822 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
823 errno = ERANGE; \
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 *output = (rtype) result; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
827 return 0
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
828
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
829 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
830 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
831 }
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_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
834 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
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_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
838 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
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_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
842 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
843 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
844 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
845
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
846 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
847 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
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_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
851 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
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_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
855 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
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_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
859 // TODO: implement
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
860 return -1;
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
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
863 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
864 #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
865 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
866 #else
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
867 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
868 #endif
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
869 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
870
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
871 #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
872 uint64_t result; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
873 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
874 return -1; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
875 } \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
876 if (result > rmax) { \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
877 errno = ERANGE; \
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 *output = (rtype) result; \
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
881 return 0
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
882
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
883 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
884 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
885 }
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_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
888 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
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_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
892 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
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_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
896 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
897 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
898 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
899
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
900 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
901 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
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_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
905 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
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_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
909 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
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_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
913 // TODO: implement
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
914 return -1;
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
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
917 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
918 #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
919 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
920 #else
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
921 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
922 #endif
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
923 }
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
924
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
925 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
926 // TODO: impl
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
927 return -1;
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
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
930 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
931 // TODO: impl
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
932 return -1;
12f38affefd5 implement all string to number conversions that are just wrappers
Mike Becker <universe@uap-core.de>
parents: 1041
diff changeset
933 }

mercurial