Minor fixes to improve regex debugging code.

tglsfdc · tglsfdc · commit 2dd6733108f2 · 2021-02-14T19:53:42.000-05:00
When REG_DEBUG is defined, ensure that an un-filled "struct cnfa"
is all-zeroes, not just that it has nstates == 0.  This is mainly
so that looking at "struct subre" structs in gdb doesn't distract
one with a lot of garbage fields during regex compilation.

Adjust some places that print debug output to have suitable fflush
calls afterwards.

In passing, correct an erroneous ancient comment: the concatenation
subre-s created by parsebranch() have op == '.' not ','.

Noted while fooling around with some regex performance improvements.
diff --git a/src/backend/regex/regc_nfa.c b/src/backend/regex/regc_nfa.c
@@ -2951,11 +2951,11 @@ carc_cmp(const void *a, const void *b)
 static void
 freecnfa(struct cnfa *cnfa)
 {
-	assert(cnfa->nstates != 0); /* not empty already */
-	cnfa->nstates = 0;
+	assert(!NULLCNFA(*cnfa));	/* not empty already */
 	FREE(cnfa->stflags);
 	FREE(cnfa->states);
 	FREE(cnfa->arcs);
+	ZAPCNFA(*cnfa);
 }
 
 /*
@@ -3012,13 +3012,13 @@ dumpstate(struct state *s,
 		fprintf(f, "\tno out arcs\n");
 	else
 		dumparcs(s, f);
-	fflush(f);
 	for (a = s->ins; a != NULL; a = a->inchain)
 	{
 		if (a->to != s)
 			fprintf(f, "\tlink from %d to %d on %d's in-chain\n",
 					a->from->no, a->to->no, s->no);
 	}
+	fflush(f);
 }
 
 /*
diff --git a/src/backend/regex/regcomp.c b/src/backend/regex/regcomp.c
@@ -479,7 +479,10 @@ pg_regcomp(regex_t *re,
 
 #ifdef REG_DEBUG
 	if (flags & REG_DUMP)
+	{
 		dump(re, stdout);
+		fflush(stdout);
+	}
 #endif
 
 	assert(v->err == 0);
@@ -721,7 +724,7 @@ parse(struct vars *v,
  *
  * This mostly manages concatenation, working closely with parseqatom().
  * Concatenated things are bundled up as much as possible, with separate
- * ',' nodes introduced only when necessary due to substructure.
+ * '.' nodes introduced only when necessary due to substructure.
  */
 static struct subre *
 parsebranch(struct vars *v,
diff --git a/src/include/regex/regguts.h b/src/include/regex/regguts.h
@@ -368,7 +368,15 @@ struct cnfa
 	struct carc *arcs;			/* the area for the lists */
 };
 
+/*
+ * When debugging, it's helpful if an un-filled CNFA is all-zeroes.
+ * In production, though, we only require nstates to be zero.
+ */
+#ifdef REG_DEBUG
+#define ZAPCNFA(cnfa)	memset(&(cnfa), 0, sizeof(cnfa))
+#else
 #define ZAPCNFA(cnfa)	((cnfa).nstates = 0)
+#endif
 #define NULLCNFA(cnfa)	((cnfa).nstates == 0)
 
 /*

Original file line number	Diff line number	Diff line change
`@@ -2951,11 +2951,11 @@ carc_cmp(const void a, const void b)`
`2951`	`2951`	`static void`
`2952`	`2952`	`freecnfa(struct cnfa *cnfa)`
`2953`	`2953`	`{`
`2954`		`- assert(cnfa->nstates != 0); /* not empty already */`
`2955`		`- cnfa->nstates = 0;`
	`2954`	`+ assert(!NULLCNFA(cnfa)); / not empty already */`
`2956`	`2955`	`FREE(cnfa->stflags);`
`2957`	`2956`	`FREE(cnfa->states);`
`2958`	`2957`	`FREE(cnfa->arcs);`
	`2958`	`+ ZAPCNFA(*cnfa);`
`2959`	`2959`	`}`
`2960`	`2960`
`2961`	`2961`	`/*`
`@@ -3012,13 +3012,13 @@ dumpstate(struct state *s,`
`3012`	`3012`	`fprintf(f, "\tno out arcs\n");`
`3013`	`3013`	`else`
`3014`	`3014`	`dumparcs(s, f);`
`3015`		`- fflush(f);`
`3016`	`3015`	`for (a = s->ins; a != NULL; a = a->inchain)`
`3017`	`3016`	`{`
`3018`	`3017`	`if (a->to != s)`
`3019`	`3018`	`fprintf(f, "\tlink from %d to %d on %d's in-chain\n",`
`3020`	`3019`	`a->from->no, a->to->no, s->no);`
`3021`	`3020`	`}`
	`3021`	`+ fflush(f);`
`3022`	`3022`	`}`
`3023`	`3023`
`3024`	`3024`	`/*`