src/regex/debug.c

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <stdlib.h>
#include <sys/types.h>
#include "regex.h"

#include "utils.h"
#include "regex2.h"
#include "debug.ih"

/*
 - regprint - print a regexp for debugging
 == void regprint(regex_t *r, FILE *d);
 */
void
regprint(r, d)
regex_t *r;
FILE *d;
{
	register struct re_guts *g = r->re_g;
	register int i;
	register int c;
	register int last;
	int nincat[NC];

	fprintf(d, "%ld states, %d categories", (long)g->nstates,
							g->ncategories);
	fprintf(d, ", first %ld last %ld", (long)g->firststate,
						(long)g->laststate);
	if (g->iflags&USEBOL)
		fprintf(d, ", USEBOL");
	if (g->iflags&USEEOL)
		fprintf(d, ", USEEOL");
	if (g->iflags&BAD)
		fprintf(d, ", BAD");
	if (g->nsub > 0)
		fprintf(d, ", nsub=%ld", (long)g->nsub);
	if (g->must != NULL)
		fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
								g->must);
	if (g->backrefs)
		fprintf(d, ", backrefs");
	if (g->nplus > 0)
		fprintf(d, ", nplus %ld", (long)g->nplus);
	fprintf(d, "\n");
	s_print(g, d);
	for (i = 0; i < g->ncategories; i++) {
		nincat[i] = 0;
		for (c = CHAR_MIN; c <= CHAR_MAX; c++)
			if (g->categories[c] == i)
				nincat[i]++;
	}
	fprintf(d, "cc0#%d", nincat[0]);
	for (i = 1; i < g->ncategories; i++)
		if (nincat[i] == 1) {
			for (c = CHAR_MIN; c <= CHAR_MAX; c++)
				if (g->categories[c] == i)
					break;
			fprintf(d, ", %d=%s", i, regchar(c));
		}
	fprintf(d, "\n");
	for (i = 1; i < g->ncategories; i++)
		if (nincat[i] != 1) {
			fprintf(d, "cc%d\t", i);
			last = -1;
			for (c = CHAR_MIN; c <= CHAR_MAX+1; c++)	/* +1 does flush */
				if (c <= CHAR_MAX && g->categories[c] == i) {
					if (last < 0) {
						fprintf(d, "%s", regchar(c));
						last = c;
					}
				} else {
					if (last >= 0) {
						if (last != c-1)
							fprintf(d, "-%s",
								regchar(c-1));
						last = -1;
					}
				}
			fprintf(d, "\n");
		}
}

/*
 - s_print - print the strip for debugging
 == static void s_print(register struct re_guts *g, FILE *d);
 */
static void
s_print(g, d)
register struct re_guts *g;
FILE *d;
{
	register sop *s;
	register cset *cs;
	register int i;
	register int done = 0;
	register sop opnd;
	register int col = 0;
	register int last;
	register sopno offset = 2;
#	define	GAP()	{	if (offset % 5 == 0) { \
					if (col > 40) { \
						fprintf(d, "\n\t"); \
						col = 0; \
					} else { \
						fprintf(d, " "); \
						col++; \
					} \
				} else \
					col++; \
				offset++; \
			}

	if (OP(g->strip[0]) != OEND)
		fprintf(d, "missing initial OEND!\n");
	for (s = &g->strip[1]; !done; s++) {
		opnd = OPND(*s);
		switch (OP(*s)) {
		case OEND:
			fprintf(d, "\n");
			done = 1;
			break;
		case OCHAR:
			if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
				fprintf(d, "\\%c", (char)opnd);
			else
				fprintf(d, "%s", regchar((char)opnd));
			break;
		case OBOL:
			fprintf(d, "^");
			break;
		case OEOL:
			fprintf(d, "$");
			break;
		case OBOW:
			fprintf(d, "\\{");
			break;
		case OEOW:
			fprintf(d, "\\}");
			break;
		case OANY:
			fprintf(d, ".");
			break;
		case OANYOF:
			fprintf(d, "[(%ld)", (long)opnd);
			cs = &g->sets[opnd];
			last = -1;
			for (i = 0; i < g->csetsize+1; i++)	/* +1 flushes */
				if (CHIN(cs, i) && i < g->csetsize) {
					if (last < 0) {
						fprintf(d, "%s", regchar(i));
						last = i;
					}
				} else {
					if (last >= 0) {
						if (last != i-1)
							fprintf(d, "-%s",
								regchar(i-1));
						last = -1;
					}
				}
			fprintf(d, "]");
			break;
		case OBACK_:
			fprintf(d, "(\\<%ld>", (long)opnd);
			break;
		case O_BACK:
			fprintf(d, "<%ld>\\)", (long)opnd);
			break;
		case OPLUS_:
			fprintf(d, "(+");
			if (OP(*(s+opnd)) != O_PLUS)
				fprintf(d, "<%ld>", (long)opnd);
			break;
		case O_PLUS:
			if (OP(*(s-opnd)) != OPLUS_)
				fprintf(d, "<%ld>", (long)opnd);
			fprintf(d, "+)");
			break;
		case OQUEST_:
			fprintf(d, "(?");
			if (OP(*(s+opnd)) != O_QUEST)
				fprintf(d, "<%ld>", (long)opnd);
			break;
		case O_QUEST:
			if (OP(*(s-opnd)) != OQUEST_)
				fprintf(d, "<%ld>", (long)opnd);
			fprintf(d, "?)");
			break;
		case OLPAREN:
			fprintf(d, "((<%ld>", (long)opnd);
			break;
		case ORPAREN:
			fprintf(d, "<%ld>))", (long)opnd);
			break;
		case OCH_:
			fprintf(d, "<");
			if (OP(*(s+opnd)) != OOR2)
				fprintf(d, "<%ld>", (long)opnd);
			break;
		case OOR1:
			if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
				fprintf(d, "<%ld>", (long)opnd);
			fprintf(d, "|");
			break;
		case OOR2:
			fprintf(d, "|");
			if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
				fprintf(d, "<%ld>", (long)opnd);
			break;
		case O_CH:
			if (OP(*(s-opnd)) != OOR1)
				fprintf(d, "<%ld>", (long)opnd);
			fprintf(d, ">");
			break;
		default:
			fprintf(d, "!%d(%d)!", OP(*s), opnd);
			break;
		}
		if (!done)
			GAP();
	}
}

/*
 - regchar - make a character printable
 == static char *regchar(int ch);
 */
static char *			/* -> representation */
regchar(ch)
int ch;
{
	static char buf[10];

	if (isprint(ch) || ch == ' ')
		sprintf(buf, "%c", ch);
	else
		sprintf(buf, "\\%o", ch);
	return(buf);
}
Commit	Line	Data
	1	#include <stdio.h>
	2	#include <string.h>
	3	#include <ctype.h>
	4	#include <limits.h>
	5	#include <stdlib.h>
	6	#include <sys/types.h>
	7	#include "regex.h"
	8
	9	#include "utils.h"
	10	#include "regex2.h"
	11	#include "debug.ih"
	12
	13	/*
	14	- regprint - print a regexp for debugging
	15	== void regprint(regex_t r, FILE d);
	16	*/
	17	void
	18	regprint(r, d)
	19	regex_t *r;
	20	FILE *d;
	21	{
	22	register struct re_guts *g = r->re_g;
	23	register int i;
	24	register int c;
	25	register int last;
	26	int nincat[NC];
	27
	28	fprintf(d, "%ld states, %d categories", (long)g->nstates,
	29	g->ncategories);
	30	fprintf(d, ", first %ld last %ld", (long)g->firststate,
	31	(long)g->laststate);
	32	if (g->iflags&USEBOL)
	33	fprintf(d, ", USEBOL");
	34	if (g->iflags&USEEOL)
	35	fprintf(d, ", USEEOL");
	36	if (g->iflags&BAD)
	37	fprintf(d, ", BAD");
	38	if (g->nsub > 0)
	39	fprintf(d, ", nsub=%ld", (long)g->nsub);
	40	if (g->must != NULL)
	41	fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
	42	g->must);
	43	if (g->backrefs)
	44	fprintf(d, ", backrefs");
	45	if (g->nplus > 0)
	46	fprintf(d, ", nplus %ld", (long)g->nplus);
	47	fprintf(d, "\n");
	48	s_print(g, d);
	49	for (i = 0; i < g->ncategories; i++) {
	50	nincat[i] = 0;
	51	for (c = CHAR_MIN; c <= CHAR_MAX; c++)
	52	if (g->categories[c] == i)
	53	nincat[i]++;
	54	}
	55	fprintf(d, "cc0#%d", nincat[0]);
	56	for (i = 1; i < g->ncategories; i++)
	57	if (nincat[i] == 1) {
	58	for (c = CHAR_MIN; c <= CHAR_MAX; c++)
	59	if (g->categories[c] == i)
	60	break;
	61	fprintf(d, ", %d=%s", i, regchar(c));
	62	}
	63	fprintf(d, "\n");
	64	for (i = 1; i < g->ncategories; i++)
	65	if (nincat[i] != 1) {
	66	fprintf(d, "cc%d\t", i);
	67	last = -1;
	68	for (c = CHAR_MIN; c <= CHAR_MAX+1; c++) /* +1 does flush */
	69	if (c <= CHAR_MAX && g->categories[c] == i) {
	70	if (last < 0) {
	71	fprintf(d, "%s", regchar(c));
	72	last = c;
	73	}
	74	} else {
	75	if (last >= 0) {
	76	if (last != c-1)
	77	fprintf(d, "-%s",
	78	regchar(c-1));
	79	last = -1;
	80	}
	81	}
	82	fprintf(d, "\n");
	83	}
	84	}
	85
	86	/*
	87	- s_print - print the strip for debugging
	88	== static void s_print(register struct re_guts g, FILE d);
	89	*/
	90	static void
	91	s_print(g, d)
	92	register struct re_guts *g;
	93	FILE *d;
	94	{
	95	register sop *s;
	96	register cset *cs;
	97	register int i;
	98	register int done = 0;
	99	register sop opnd;
	100	register int col = 0;
	101	register int last;
	102	register sopno offset = 2;
	103	# define GAP() { if (offset % 5 == 0) { \
	104	if (col > 40) { \
	105	fprintf(d, "\n\t"); \
	106	col = 0; \
	107	} else { \
	108	fprintf(d, " "); \
	109	col++; \
	110	} \
	111	} else \
	112	col++; \
	113	offset++; \
	114	}
	115
	116	if (OP(g->strip[0]) != OEND)
	117	fprintf(d, "missing initial OEND!\n");
	118	for (s = &g->strip[1]; !done; s++) {
	119	opnd = OPND(*s);
	120	switch (OP(*s)) {
	121	case OEND:
	122	fprintf(d, "\n");
	123	done = 1;
	124	break;
	125	case OCHAR:
	126	if (strchr("\\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
	127	fprintf(d, "\\%c", (char)opnd);
	128	else
	129	fprintf(d, "%s", regchar((char)opnd));
	130	break;
	131	case OBOL:
	132	fprintf(d, "^");
	133	break;
	134	case OEOL:
	135	fprintf(d, "$");
	136	break;
	137	case OBOW:
	138	fprintf(d, "\\{");
	139	break;
	140	case OEOW:
	141	fprintf(d, "\\}");
	142	break;
	143	case OANY:
	144	fprintf(d, ".");
	145	break;
	146	case OANYOF:
	147	fprintf(d, "[(%ld)", (long)opnd);
	148	cs = &g->sets[opnd];
	149	last = -1;
	150	for (i = 0; i < g->csetsize+1; i++) /* +1 flushes */
	151	if (CHIN(cs, i) && i < g->csetsize) {
	152	if (last < 0) {
	153	fprintf(d, "%s", regchar(i));
	154	last = i;
	155	}
	156	} else {
	157	if (last >= 0) {
	158	if (last != i-1)
	159	fprintf(d, "-%s",
	160	regchar(i-1));
	161	last = -1;
	162	}
	163	}
	164	fprintf(d, "]");
	165	break;
	166	case OBACK_:
	167	fprintf(d, "(\\<%ld>", (long)opnd);
	168	break;
	169	case O_BACK:
	170	fprintf(d, "<%ld>\\)", (long)opnd);
	171	break;
	172	case OPLUS_:
	173	fprintf(d, "(+");
	174	if (OP(*(s+opnd)) != O_PLUS)
	175	fprintf(d, "<%ld>", (long)opnd);
	176	break;
	177	case O_PLUS:
	178	if (OP(*(s-opnd)) != OPLUS_)
	179	fprintf(d, "<%ld>", (long)opnd);
	180	fprintf(d, "+)");
	181	break;
	182	case OQUEST_:
	183	fprintf(d, "(?");
	184	if (OP(*(s+opnd)) != O_QUEST)
	185	fprintf(d, "<%ld>", (long)opnd);
	186	break;
	187	case O_QUEST:
	188	if (OP(*(s-opnd)) != OQUEST_)
	189	fprintf(d, "<%ld>", (long)opnd);
	190	fprintf(d, "?)");
	191	break;
	192	case OLPAREN:
	193	fprintf(d, "((<%ld>", (long)opnd);
	194	break;
	195	case ORPAREN:
	196	fprintf(d, "<%ld>))", (long)opnd);
	197	break;
	198	case OCH_:
	199	fprintf(d, "<");
	200	if (OP(*(s+opnd)) != OOR2)
	201	fprintf(d, "<%ld>", (long)opnd);
	202	break;
	203	case OOR1:
	204	if (OP((s-opnd)) != OOR1 && OP((s-opnd)) != OCH_)
	205	fprintf(d, "<%ld>", (long)opnd);
	206	fprintf(d, "\|");
	207	break;
	208	case OOR2:
	209	fprintf(d, "\|");
	210	if (OP((s+opnd)) != OOR2 && OP((s+opnd)) != O_CH)
	211	fprintf(d, "<%ld>", (long)opnd);
	212	break;
	213	case O_CH:
	214	if (OP(*(s-opnd)) != OOR1)
	215	fprintf(d, "<%ld>", (long)opnd);
	216	fprintf(d, ">");
	217	break;
	218	default:
	219	fprintf(d, "!%d(%d)!", OP(*s), opnd);
	220	break;
	221	}
	222	if (!done)
	223	GAP();
	224	}
	225	}
	226
	227	/*
	228	- regchar - make a character printable
	229	== static char *regchar(int ch);
	230	*/
	231	static char * /* -> representation */
	232	regchar(ch)
	233	int ch;
	234	{
	235	static char buf[10];
	236
	237	if (isprint(ch) \|\| ch == ' ')
	238	sprintf(buf, "%c", ch);
	239	else
	240	sprintf(buf, "\\%o", ch);
	241	return(buf);
	242	}