4
int split(char *string, char *fields[], int nfields, char *sep);
7
- split - divide a string into fields, like awk split()
8
= int split(char *string, char *fields[], int nfields, char *sep);
10
int /* number of fields, including overflow */
12
char *fields[], /* list is not NULL-terminated */
13
int nfields, /* number of entries available in fields[] */
14
char *sep) /* "" white, "c" single char, "ab" [ab]+ */
16
register char *p = string;
17
register char c; /* latest character */
18
register char sepc = sep[0];
21
register char **fp = fields;
23
register int trimtrail;
27
while ((c = *p++) == ' ' || c == '\t')
31
sep = (char*) " \t"; /* note, code below knows this is 2 long */
35
sepc2 = sep[1]; /* now we can safely pick this up */
41
/* single separator */
49
while ((c = *p++) != sepc)
54
/* we have overflowed the fields vector -- just count them */
57
while ((c = *p++) != sepc)
71
while ((c = *p++) != sepc && c != sepc2)
73
if (trimtrail && **(fp-1) == '\0')
80
while ((c = *p++) == sepc || c == sepc2)
84
/* we have overflowed the fields vector -- just count them */
87
while ((c = *p++) == sepc || c == sepc2)
91
while ((c = *p++) != '\0' && c != sepc && c != sepc2)
94
/* might have to trim trailing white space */
97
while ((c = *--p) == sepc || c == sepc2)
120
while ((sepc = *sepp++) != '\0' && sepc != c)
122
if (sepc != '\0') /* it was a separator */
130
while ((sepc = *sepp++) != '\0' && sepc != c)
132
if (sepc == '\0') /* it wasn't a separator */
146
* pgm runs regression
147
* pgm sep splits stdin lines by sep
148
* pgm str sep splits str by sep
149
* pgm str sep n splits str by sep n times
162
for (n = atoi(argv[3]); n > 0; n--) {
163
(void) strcpy(buf, argv[1]);
166
for (n = atoi(argv[3]); n > 0; n--) {
167
(void) strcpy(buf, argv[1]);
168
(void) split(buf, fields, MNF, argv[2]);
171
dosplit(argv[1], argv[2]);
173
while (fgets(buf, sizeof(buf), stdin) != NULL) {
174
buf[strlen(buf)-1] = '\0'; /* stomp newline */
175
dosplit(buf, argv[1]);
183
dosplit(string, seps)
191
nf = split(string, fields, NF, seps);
192
print(nf, NF, fields);
195
print(nf, nfp, fields)
203
bound = (nf > nfp) ? nfp : nf;
205
for (fn = 0; fn < bound; fn++)
206
printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
209
#define RNF 5 /* some table entries know this */
217
" ", " ", 2, { "", "" },
218
"x", " ", 1, { "x" },
219
"xy", " ", 1, { "xy" },
220
"x y", " ", 2, { "x", "y" },
221
"abc def g ", " ", 5, { "abc", "def", "", "g", "" },
222
" a bcd", " ", 4, { "", "", "a", "bcd" },
223
"a b c d e f", " ", 6, { "a", "b", "c", "d", "e f" },
224
" a b c d ", " ", 6, { "", "a", "b", "c", "d " },
227
" ", " _", 2, { "", "" },
228
"x", " _", 1, { "x" },
229
"x y", " _", 2, { "x", "y" },
230
"ab _ cd", " _", 2, { "ab", "cd" },
231
" a_b c ", " _", 5, { "", "a", "b", "c", "" },
232
"a b c_d e f", " _", 6, { "a", "b", "c", "d", "e f" },
233
" a b c d ", " _", 6, { "", "a", "b", "c", "d " },
235
"", " _~", 0, { "" },
236
" ", " _~", 2, { "", "" },
237
"x", " _~", 1, { "x" },
238
"x y", " _~", 2, { "x", "y" },
239
"ab _~ cd", " _~", 2, { "ab", "cd" },
240
" a_b c~", " _~", 5, { "", "a", "b", "c", "" },
241
"a b_c d~e f", " _~", 6, { "a", "b", "c", "d", "e f" },
242
"~a b c d ", " _~", 6, { "", "a", "b", "c", "d " },
244
"", " _~-", 0, { "" },
245
" ", " _~-", 2, { "", "" },
246
"x", " _~-", 1, { "x" },
247
"x y", " _~-", 2, { "x", "y" },
248
"ab _~- cd", " _~-", 2, { "ab", "cd" },
249
" a_b c~", " _~-", 5, { "", "a", "b", "c", "" },
250
"a b_c-d~e f", " _~-", 6, { "a", "b", "c", "d", "e f" },
251
"~a-b c d ", " _~-", 6, { "", "a", "b", "c", "d " },
254
" ", " ", 2, { "", "" },
255
"x", " ", 1, { "x" },
256
"xy", " ", 1, { "xy" },
257
"x y", " ", 2, { "x", "y" },
258
"abc def g ", " ", 4, { "abc", "def", "g", "" },
259
" a bcd", " ", 3, { "", "a", "bcd" },
260
"a b c d e f", " ", 6, { "a", "b", "c", "d", "e f" },
261
" a b c d ", " ", 6, { "", "a", "b", "c", "d " },
266
"xy", "", 1, { "xy" },
267
"x y", "", 2, { "x", "y" },
268
"abc def g ", "", 3, { "abc", "def", "g" },
269
"\t a bcd", "", 2, { "a", "bcd" },
270
" a \tb\t c ", "", 3, { "a", "b", "c" },
271
"a b c d e ", "", 5, { "a", "b", "c", "d", "e" },
272
"a b\tc d e f", "", 6, { "a", "b", "c", "d", "e f" },
273
" a b c d e f ", "", 6, { "a", "b", "c", "d", "e f " },
275
NULL, NULL, 0, { NULL },
285
register int printit;
288
for (n = 0; tests[n].str != NULL; n++) {
289
(void) strcpy(buf, tests[n].str);
291
nf = split(buf, fields, RNF, tests[n].seps);
293
if (nf != tests[n].nf) {
294
printf("split `%s' by `%s' gave %d fields, not %d\n",
295
tests[n].str, tests[n].seps, nf, tests[n].nf);
297
} else if (fields[RNF] != NULL) {
298
printf("split() went beyond array end\n");
301
for (i = 0; i < nf && i < RNF; i++) {
305
if (strcmp(f, tests[n].fi[i]) != 0) {
306
printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
307
tests[n].str, tests[n].seps,
308
i, fields[i], tests[n].fi[i]);
314
print(nf, RNF, fields);
added
removed
regex/split.c
