1 #include <stdio.h>
2 #include <string.h>
3
4 /*
5 - split - divide a string into fields, like awk split()
6 = int split(char *string, char *fields[], int nfields, char *sep);
7 */
8 int /* number of fields, including overflow */
split(string,fields,nfields,sep)9 split(string, fields, nfields, sep)
10 char *string;
11 char *fields[]; /* list is not NULL-terminated */
12 int nfields; /* number of entries available in fields[] */
13 char *sep; /* "" white, "c" single char, "ab" [ab]+ */
14 {
15 register char *p = string;
16 register char c; /* latest character */
17 register char sepc = sep[0];
18 register char sepc2;
19 register int fn;
20 register char **fp = fields;
21 register char *sepp;
22 register int trimtrail;
23
24 /* white space */
25 if (sepc == '\0') {
26 while ((c = *p++) == ' ' || c == '\t')
27 continue;
28 p--;
29 trimtrail = 1;
30 sep = " \t"; /* note, code below knows this is 2 long */
31 sepc = ' ';
32 } else
33 trimtrail = 0;
34 sepc2 = sep[1]; /* now we can safely pick this up */
35
36 /* catch empties */
37 if (*p == '\0')
38 return(0);
39
40 /* single separator */
41 if (sepc2 == '\0') {
42 fn = nfields;
43 for (;;) {
44 *fp++ = p;
45 fn--;
46 if (fn == 0)
47 break;
48 while ((c = *p++) != sepc)
49 if (c == '\0')
50 return(nfields - fn);
51 *(p-1) = '\0';
52 }
53 /* we have overflowed the fields vector -- just count them */
54 fn = nfields;
55 for (;;) {
56 while ((c = *p++) != sepc)
57 if (c == '\0')
58 return(fn);
59 fn++;
60 }
61 /* not reached */
62 }
63
64 /* two separators */
65 if (sep[2] == '\0') {
66 fn = nfields;
67 for (;;) {
68 *fp++ = p;
69 fn--;
70 while ((c = *p++) != sepc && c != sepc2)
71 if (c == '\0') {
72 if (trimtrail && **(fp-1) == '\0')
73 fn++;
74 return(nfields - fn);
75 }
76 if (fn == 0)
77 break;
78 *(p-1) = '\0';
79 while ((c = *p++) == sepc || c == sepc2)
80 continue;
81 p--;
82 }
83 /* we have overflowed the fields vector -- just count them */
84 fn = nfields;
85 while (c != '\0') {
86 while ((c = *p++) == sepc || c == sepc2)
87 continue;
88 p--;
89 fn++;
90 while ((c = *p++) != '\0' && c != sepc && c != sepc2)
91 continue;
92 }
93 /* might have to trim trailing white space */
94 if (trimtrail) {
95 p--;
96 while ((c = *--p) == sepc || c == sepc2)
97 continue;
98 p++;
99 if (*p != '\0') {
100 if (fn == nfields+1)
101 *p = '\0';
102 fn--;
103 }
104 }
105 return(fn);
106 }
107
108 /* n separators */
109 fn = 0;
110 for (;;) {
111 if (fn < nfields)
112 *fp++ = p;
113 fn++;
114 for (;;) {
115 c = *p++;
116 if (c == '\0')
117 return(fn);
118 sepp = sep;
119 while ((sepc = *sepp++) != '\0' && sepc != c)
120 continue;
121 if (sepc != '\0') /* it was a separator */
122 break;
123 }
124 if (fn < nfields)
125 *(p-1) = '\0';
126 for (;;) {
127 c = *p++;
128 sepp = sep;
129 while ((sepc = *sepp++) != '\0' && sepc != c)
130 continue;
131 if (sepc == '\0') /* it wasn't a separator */
132 break;
133 }
134 p--;
135 }
136
137 /* not reached */
138 }
139
140 #ifdef TEST_SPLIT
141
142
143 /*
144 * test program
145 * pgm runs regression
146 * pgm sep splits stdin lines by sep
147 * pgm str sep splits str by sep
148 * pgm str sep n splits str by sep n times
149 */
150 int
main(argc,argv)151 main(argc, argv)
152 int argc;
153 char *argv[];
154 {
155 char buf[512];
156 register int n;
157 # define MNF 10
158 char *fields[MNF];
159
160 if (argc > 4)
161 for (n = atoi(argv[3]); n > 0; n--) {
162 (void) strcpy(buf, argv[1]);
163 }
164 else if (argc > 3)
165 for (n = atoi(argv[3]); n > 0; n--) {
166 (void) strcpy(buf, argv[1]);
167 (void) split(buf, fields, MNF, argv[2]);
168 }
169 else if (argc > 2)
170 dosplit(argv[1], argv[2]);
171 else if (argc > 1)
172 while (fgets(buf, sizeof(buf), stdin) != NULL) {
173 buf[strlen(buf)-1] = '\0'; /* stomp newline */
174 dosplit(buf, argv[1]);
175 }
176 else
177 regress();
178
179 exit(0);
180 }
181
dosplit(string,seps)182 dosplit(string, seps)
183 char *string;
184 char *seps;
185 {
186 # define NF 5
187 char *fields[NF];
188 register int nf;
189
190 nf = split(string, fields, NF, seps);
191 print(nf, NF, fields);
192 }
193
print(nf,nfp,fields)194 print(nf, nfp, fields)
195 int nf;
196 int nfp;
197 char *fields[];
198 {
199 register int fn;
200 register int bound;
201
202 bound = (nf > nfp) ? nfp : nf;
203 printf("%d:\t", nf);
204 for (fn = 0; fn < bound; fn++)
205 printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
206 }
207
208 #define RNF 5 /* some table entries know this */
209 struct {
210 char *str;
211 char *seps;
212 int nf;
213 char *fi[RNF];
214 } tests[] = {
215 "", " ", 0, { "" },
216 " ", " ", 2, { "", "" },
217 "x", " ", 1, { "x" },
218 "xy", " ", 1, { "xy" },
219 "x y", " ", 2, { "x", "y" },
220 "abc def g ", " ", 5, { "abc", "def", "", "g", "" },
221 " a bcd", " ", 4, { "", "", "a", "bcd" },
222 "a b c d e f", " ", 6, { "a", "b", "c", "d", "e f" },
223 " a b c d ", " ", 6, { "", "a", "b", "c", "d " },
224
225 "", " _", 0, { "" },
226 " ", " _", 2, { "", "" },
227 "x", " _", 1, { "x" },
228 "x y", " _", 2, { "x", "y" },
229 "ab _ cd", " _", 2, { "ab", "cd" },
230 " a_b c ", " _", 5, { "", "a", "b", "c", "" },
231 "a b c_d e f", " _", 6, { "a", "b", "c", "d", "e f" },
232 " a b c d ", " _", 6, { "", "a", "b", "c", "d " },
233
234 "", " _~", 0, { "" },
235 " ", " _~", 2, { "", "" },
236 "x", " _~", 1, { "x" },
237 "x y", " _~", 2, { "x", "y" },
238 "ab _~ cd", " _~", 2, { "ab", "cd" },
239 " a_b c~", " _~", 5, { "", "a", "b", "c", "" },
240 "a b_c d~e f", " _~", 6, { "a", "b", "c", "d", "e f" },
241 "~a b c d ", " _~", 6, { "", "a", "b", "c", "d " },
242
243 "", " _~-", 0, { "" },
244 " ", " _~-", 2, { "", "" },
245 "x", " _~-", 1, { "x" },
246 "x y", " _~-", 2, { "x", "y" },
247 "ab _~- cd", " _~-", 2, { "ab", "cd" },
248 " a_b c~", " _~-", 5, { "", "a", "b", "c", "" },
249 "a b_c-d~e f", " _~-", 6, { "a", "b", "c", "d", "e f" },
250 "~a-b c d ", " _~-", 6, { "", "a", "b", "c", "d " },
251
252 "", " ", 0, { "" },
253 " ", " ", 2, { "", "" },
254 "x", " ", 1, { "x" },
255 "xy", " ", 1, { "xy" },
256 "x y", " ", 2, { "x", "y" },
257 "abc def g ", " ", 4, { "abc", "def", "g", "" },
258 " a bcd", " ", 3, { "", "a", "bcd" },
259 "a b c d e f", " ", 6, { "a", "b", "c", "d", "e f" },
260 " a b c d ", " ", 6, { "", "a", "b", "c", "d " },
261
262 "", "", 0, { "" },
263 " ", "", 0, { "" },
264 "x", "", 1, { "x" },
265 "xy", "", 1, { "xy" },
266 "x y", "", 2, { "x", "y" },
267 "abc def g ", "", 3, { "abc", "def", "g" },
268 "\t a bcd", "", 2, { "a", "bcd" },
269 " a \tb\t c ", "", 3, { "a", "b", "c" },
270 "a b c d e ", "", 5, { "a", "b", "c", "d", "e" },
271 "a b\tc d e f", "", 6, { "a", "b", "c", "d", "e f" },
272 " a b c d e f ", "", 6, { "a", "b", "c", "d", "e f " },
273
274 NULL, NULL, 0, { NULL },
275 };
276
regress()277 regress()
278 {
279 char buf[512];
280 register int n;
281 char *fields[RNF+1];
282 register int nf;
283 register int i;
284 register int printit;
285 register char *f;
286
287 for (n = 0; tests[n].str != NULL; n++) {
288 (void) strcpy(buf, tests[n].str);
289 fields[RNF] = NULL;
290 nf = split(buf, fields, RNF, tests[n].seps);
291 printit = 0;
292 if (nf != tests[n].nf) {
293 printf("split `%s' by `%s' gave %d fields, not %d\n",
294 tests[n].str, tests[n].seps, nf, tests[n].nf);
295 printit = 1;
296 } else if (fields[RNF] != NULL) {
297 printf("split() went beyond array end\n");
298 printit = 1;
299 } else {
300 for (i = 0; i < nf && i < RNF; i++) {
301 f = fields[i];
302 if (f == NULL)
303 f = "(NULL)";
304 if (strcmp(f, tests[n].fi[i]) != 0) {
305 printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
306 tests[n].str, tests[n].seps,
307 i, fields[i], tests[n].fi[i]);
308 printit = 1;
309 }
310 }
311 }
312 if (printit)
313 print(nf, RNF, fields);
314 }
315 }
316 #endif
317
