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
	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