![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to split.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / ereg / regex|
Return to split.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / ereg / regex |
1.1 misho 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 */
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
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:
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:
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:
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