[wxWidgets.git] / src / regex / split.c

#include <stdio.h>
#include <string.h>

/*
 - split - divide a string into fields, like awk split()
 = int split(char *string, char *fields[], int nfields, char *sep);
 */
int				/* number of fields, including overflow */
split(string, fields, nfields, sep)
char *string;
char *fields[];			/* list is not NULL-terminated */
int nfields;			/* number of entries available in fields[] */
char *sep;			/* "" white, "c" single char, "ab" [ab]+ */
{
	register char *p = string;
	register char c;			/* latest character */
	register char sepc = sep[0];
	register char sepc2;
	register int fn;
	register char **fp = fields;
	register char *sepp;
	register int trimtrail;

	/* white space */
	if (sepc == '\0') {
		while ((c = *p++) == ' ' || c == '\t')
			continue;
		p--;
		trimtrail = 1;
		sep = " \t";	/* note, code below knows this is 2 long */
		sepc = ' ';
	} else
		trimtrail = 0;
	sepc2 = sep[1];		/* now we can safely pick this up */

	/* catch empties */
	if (*p == '\0')
		return(0);

	/* single separator */
	if (sepc2 == '\0') {
		fn = nfields;
		for (;;) {
			*fp++ = p;
			fn--;
			if (fn == 0)
				break;
			while ((c = *p++) != sepc)
				if (c == '\0')
					return(nfields - fn);
			*(p-1) = '\0';
		}
		/* we have overflowed the fields vector -- just count them */
		fn = nfields;
		for (;;) {
			while ((c = *p++) != sepc)
				if (c == '\0')
					return(fn);
			fn++;
		}
		/* not reached */
	}

	/* two separators */
	if (sep[2] == '\0') {
		fn = nfields;
		for (;;) {
			*fp++ = p;
			fn--;
			while ((c = *p++) != sepc && c != sepc2)
				if (c == '\0') {
					if (trimtrail && **(fp-1) == '\0')
						fn++;
					return(nfields - fn);
				}
			if (fn == 0)
				break;
			*(p-1) = '\0';
			while ((c = *p++) == sepc || c == sepc2)
				continue;
			p--;
		}
		/* we have overflowed the fields vector -- just count them */
		fn = nfields;
		while (c != '\0') {
			while ((c = *p++) == sepc || c == sepc2)
				continue;
			p--;
			fn++;
			while ((c = *p++) != '\0' && c != sepc && c != sepc2)
				continue;
		}
		/* might have to trim trailing white space */
		if (trimtrail) {
			p--;
			while ((c = *--p) == sepc || c == sepc2)
				continue;
			p++;
			if (*p != '\0') {
				if (fn == nfields+1)
					*p = '\0';
				fn--;
			}
		}
		return(fn);
	}

	/* n separators */
	fn = 0;
	for (;;) {
		if (fn < nfields)
			*fp++ = p;
		fn++;
		for (;;) {
			c = *p++;
			if (c == '\0')
				return(fn);
			sepp = sep;
			while ((sepc = *sepp++) != '\0' && sepc != c)
				continue;
			if (sepc != '\0')	/* it was a separator */
				break;
		}
		if (fn < nfields)
			*(p-1) = '\0';
		for (;;) {
			c = *p++;
			sepp = sep;
			while ((sepc = *sepp++) != '\0' && sepc != c)
				continue;
			if (sepc == '\0')	/* it wasn't a separator */
				break;
		}
		p--;
	}

	/* not reached */
}

#ifdef TEST_SPLIT


/*
 * test program
 * pgm		runs regression
 * pgm sep	splits stdin lines by sep
 * pgm str sep	splits str by sep
 * pgm str sep n	splits str by sep n times
 */
int
main(argc, argv)
int argc;
char *argv[];
{
	char buf[512];
	register int n;
#	define	MNF	10
	char *fields[MNF];

	if (argc > 4)
		for (n = atoi(argv[3]); n > 0; n--) {
			(void) strcpy(buf, argv[1]);
		}
	else if (argc > 3)
		for (n = atoi(argv[3]); n > 0; n--) {
			(void) strcpy(buf, argv[1]);
			(void) split(buf, fields, MNF, argv[2]);
		}
	else if (argc > 2)
		dosplit(argv[1], argv[2]);
	else if (argc > 1)
		while (fgets(buf, sizeof(buf), stdin) != NULL) {
			buf[strlen(buf)-1] = '\0';	/* stomp newline */
			dosplit(buf, argv[1]);
		}
	else
		regress();

	exit(0);
}

dosplit(string, seps)
char *string;
char *seps;
{
#	define	NF	5
	char *fields[NF];
	register int nf;

	nf = split(string, fields, NF, seps);
	print(nf, NF, fields);
}

print(nf, nfp, fields)
int nf;
int nfp;
char *fields[];
{
	register int fn;
	register int bound;

	bound = (nf > nfp) ? nfp : nf;
	printf("%d:\t", nf);
	for (fn = 0; fn < bound; fn++)
		printf("\"%s\"%s", fields[fn], (fn+1 < nf) ? ", " : "\n");
}

#define	RNF	5		/* some table entries know this */
struct {
	char *str;
	char *seps;
	int nf;
	char *fi[RNF];
} tests[] = {
	"",		" ",	0,	{ "" },
	" ",		" ",	2,	{ "", "" },
	"x",		" ",	1,	{ "x" },
	"xy",		" ",	1,	{ "xy" },
	"x y",		" ",	2,	{ "x", "y" },
	"abc def  g ",	" ",	5,	{ "abc", "def", "", "g", "" },
	"  a bcd",	" ",	4,	{ "", "", "a", "bcd" },
	"a b c d e f",	" ",	6,	{ "a", "b", "c", "d", "e f" },
	" a b c d ",	" ",	6,	{ "", "a", "b", "c", "d " },

	"",		" _",	0,	{ "" },
	" ",		" _",	2,	{ "", "" },
	"x",		" _",	1,	{ "x" },
	"x y",		" _",	2,	{ "x", "y" },
	"ab _ cd",	" _",	2,	{ "ab", "cd" },
	" a_b  c ",	" _",	5,	{ "", "a", "b", "c", "" },
	"a b c_d e f",	" _",	6,	{ "a", "b", "c", "d", "e f" },
	" a b c d ",	" _",	6,	{ "", "a", "b", "c", "d " },

	"",		" _~",	0,	{ "" },
	" ",		" _~",	2,	{ "", "" },
	"x",		" _~",	1,	{ "x" },
	"x y",		" _~",	2,	{ "x", "y" },
	"ab _~ cd",	" _~",	2,	{ "ab", "cd" },
	" a_b  c~",	" _~",	5,	{ "", "a", "b", "c", "" },
	"a b_c d~e f",	" _~",	6,	{ "a", "b", "c", "d", "e f" },
	"~a b c d ",	" _~",	6,	{ "", "a", "b", "c", "d " },

	"",		" _~-",	0,	{ "" },
	" ",		" _~-",	2,	{ "", "" },
	"x",		" _~-",	1,	{ "x" },
	"x y",		" _~-",	2,	{ "x", "y" },
	"ab _~- cd",	" _~-",	2,	{ "ab", "cd" },
	" a_b  c~",	" _~-",	5,	{ "", "a", "b", "c", "" },
	"a b_c-d~e f",	" _~-",	6,	{ "a", "b", "c", "d", "e f" },
	"~a-b c d ",	" _~-",	6,	{ "", "a", "b", "c", "d " },

	"",		"  ",	0,	{ "" },
	" ",		"  ",	2,	{ "", "" },
	"x",		"  ",	1,	{ "x" },
	"xy",		"  ",	1,	{ "xy" },
	"x y",		"  ",	2,	{ "x", "y" },
	"abc def  g ",	"  ",	4,	{ "abc", "def", "g", "" },
	"  a bcd",	"  ",	3,	{ "", "a", "bcd" },
	"a b c d e f",	"  ",	6,	{ "a", "b", "c", "d", "e f" },
	" a b c d ",	"  ",	6,	{ "", "a", "b", "c", "d " },

	"",		"",	0,	{ "" },
	" ",		"",	0,	{ "" },
	"x",		"",	1,	{ "x" },
	"xy",		"",	1,	{ "xy" },
	"x y",		"",	2,	{ "x", "y" },
	"abc def  g ",	"",	3,	{ "abc", "def", "g" },
	"\t a bcd",	"",	2,	{ "a", "bcd" },
	"  a \tb\t c ",	"",	3,	{ "a", "b", "c" },
	"a b c d e ",	"",	5,	{ "a", "b", "c", "d", "e" },
	"a b\tc d e f",	"",	6,	{ "a", "b", "c", "d", "e f" },
	" a b c d e f ",	"",	6,	{ "a", "b", "c", "d", "e f " },

	NULL,		NULL,	0,	{ NULL },
};

regress()
{
	char buf[512];
	register int n;
	char *fields[RNF+1];
	register int nf;
	register int i;
	register int printit;
	register char *f;

	for (n = 0; tests[n].str != NULL; n++) {
		(void) strcpy(buf, tests[n].str);
		fields[RNF] = NULL;
		nf = split(buf, fields, RNF, tests[n].seps);
		printit = 0;
		if (nf != tests[n].nf) {
			printf("split `%s' by `%s' gave %d fields, not %d\n",
				tests[n].str, tests[n].seps, nf, tests[n].nf);
			printit = 1;
		} else if (fields[RNF] != NULL) {
			printf("split() went beyond array end\n");
			printit = 1;
		} else {
			for (i = 0; i < nf && i < RNF; i++) {
				f = fields[i];
				if (f == NULL)
					f = "(NULL)";
				if (strcmp(f, tests[n].fi[i]) != 0) {
					printf("split `%s' by `%s', field %d is `%s', not `%s'\n",
						tests[n].str, tests[n].seps,
						i, fields[i], tests[n].fi[i]);
					printit = 1;
				}
			}
		}
		if (printit)
			print(nf, RNF, fields);
	}
}
#endif
Commit	Line	Data
5a419892 VZ	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