Clarify RE engine code; inline a static function to a macro;

make exact string nodes smaller.
To: perl5-porters@perl.org (Mailing list Perl5)
Subject: [PATCH 5.005_60] Cosmetic change to REx engine
Message-Id: <199908030153.VAA10542@monk.mps.ohio-state.edu>

p4raw-id: //depot/cfgperl@3908

5 files changed, 57 insertions, 62 deletions

diff --git a/Makefile.SH b/Makefile.SH
index 6c6fcc42f7..1567e2f18a 100644
--- a/Makefile.SH
+++ b/Makefile.SH
@@ -548,6 +548,7 @@ SYMH = perlvars.h intrpvar.h thrdvar.h
 #	ext/ByteLoader/byterun.h:	bytecode.pl
 #	ext/ByteLoader/byterun.c:	bytecode.pl
 #	ext/B/Asmdata.pm:	bytecode.pl
+#	global.sym:	embed.pl
 #	regnodes.h:	regcomp.pl
 #	warning.h lib/warning.pm:	warning.pl
 # The correct versions should be already supplied with the perl kit,
diff --git a/embed.pl b/embed.pl
index 09035e8c6b..09df177645 100755
--- a/embed.pl
+++ b/embed.pl
@@ -1920,7 +1920,6 @@ s	|regnode*|reg		|I32|I32 *
 s	|regnode*|reganode	|U8|U32
 s	|regnode*|regatom	|I32 *
 s	|regnode*|regbranch	|I32 *|I32
-s	|void	|regc		|U8|char *
 s	|void	|reguni		|UV|char *|I32*
 s	|regnode*|regclass
 s	|regnode*|regclassutf8
diff --git a/regcomp.c b/regcomp.c
index 3fc298fc5a..b06077b419 100644
--- a/regcomp.c
+++ b/regcomp.c
@@ -196,6 +196,9 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 #define CHR_SVLEN(sv) (UTF ? sv_len_utf8(sv) : SvCUR(sv))
 #define CHR_DIST(a,b) (UTF ? utf8_distance(a,b) : a - b)
 
+/* Allow for side effects in s */
+#define REGC(c,s) STMT_START { if (!SIZE_ONLY) *(s) = (c); else (s);} STMT_END
+
 static void clear_re(pTHXo_ void *r);
 
 STATIC void
@@ -260,7 +263,7 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da
 	    regnode *stop = scan;
 #endif 
 
-	    next = scan + (*OPERAND(scan) + 2 - 1)/sizeof(regnode) + 2;
+	    next = scan + NODE_SZ_STR(scan);
 	    /* Skip NOTHING, merge EXACT*. */
 	    while (n &&
 		   ( PL_regkind[(U8)OP(n)] == NOTHING || 
@@ -279,17 +282,17 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da
 		    n = regnext(n);
 		}
 		else {
-		    int oldl = *OPERAND(scan);
+		    int oldl = STR_LEN(scan);
 		    regnode *nnext = regnext(n);
 		    
-		    if (oldl + *OPERAND(n) > U8_MAX) 
+		    if (oldl + STR_LEN(n) > U8_MAX) 
 			break;
 		    NEXT_OFF(scan) += NEXT_OFF(n);
-		    *OPERAND(scan) += *OPERAND(n);
-		    next = n + (*OPERAND(n) + 2 - 1)/sizeof(regnode) + 2;
+		    STR_LEN(scan) += STR_LEN(n);
+		    next = n + NODE_SZ_STR(n);
 		    /* Now we can overwrite *n : */
-		    Move(OPERAND(n) + 1, OPERAND(scan) + oldl + 1,
-			 *OPERAND(n) + 1, char);
+		    Move(STRING(n), STRING(scan) + oldl,
+			 STR_LEN(n), char);
 #ifdef DEBUGGING
 		    if (stringok)
 			stop = next - 1;
@@ -299,7 +302,7 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da
 	    }
 #ifdef DEBUGGING
 	    /* Allow dumping */
-	    n = scan + (*OPERAND(scan) + 2 - 1)/sizeof(regnode) + 2;
+	    n = scan + NODE_SZ_STR(scan);
 	    while (n <= stop) {
 		/* Purify reports a benign UMR here sometimes, because we
 		 * don't initialize the OP() slot of a node when that node
@@ -392,9 +395,9 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da
 	    continue;
 	}
 	else if (OP(scan) == EXACT) {
-	    I32 l = *OPERAND(scan);
+	    I32 l = STR_LEN(scan);
 	    if (UTF) {
-		unsigned char *s = (unsigned char *)(OPERAND(scan)+1);
+		unsigned char *s = (unsigned char *)STRING(scan);
 		unsigned char *e = s + l;
 		I32 newl = 0;
 		while (s < e) {
@@ -412,18 +415,18 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da
  		    data->last_start_max = is_inf
  			? I32_MAX : data->pos_min + data->pos_delta; 
 		}
-		sv_catpvn(data->last_found, (char *)(OPERAND(scan)+1), *OPERAND(scan));
+		sv_catpvn(data->last_found, STRING(scan), STR_LEN(scan));
 		data->last_end = data->pos_min + l;
 		data->pos_min += l; /* As in the first entry. */
 		data->flags &= ~SF_BEFORE_EOL;
 	    }
 	}
 	else if (PL_regkind[(U8)OP(scan)] == EXACT) {
-	    I32 l = *OPERAND(scan);
+	    I32 l = STR_LEN(scan);
 	    if (flags & SCF_DO_SUBSTR) 
 		scan_commit(data);
 	    if (UTF) {
-		unsigned char *s = (unsigned char *)(OPERAND(scan)+1);
+		unsigned char *s = (unsigned char *)STRING(scan);
 		unsigned char *e = s + l;
 		I32 newl = 0;
 		while (s < e) {
@@ -514,7 +517,7 @@ S_study_chunk(pTHX_ regnode **scanp, I32 *deltap, regnode *last, scan_data_t *da
 		    nxt = regnext(nxt);
 		    if (!strchr((char*)PL_simple,OP(nxt))
 			&& !(PL_regkind[(U8)OP(nxt)] == EXACT
-			     && *OPERAND(nxt) == 1)) 
+			     && STR_LEN(nxt) == 1)) 
 			goto nogo;
 		    nxt2 = nxt;
 		    nxt = regnext(nxt);
@@ -861,7 +864,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
     PL_regsize = 0L;
     PL_regcode = &PL_regdummy;
     PL_reg_whilem_seen = 0;
-    regc((U8)REG_MAGIC, (char*)PL_regcode);
+    REGC((U8)REG_MAGIC, (char*)PL_regcode);
     if (reg(0, &flags) == NULL) {
 	Safefree(PL_regprecomp);
 	PL_regprecomp = Nullch;
@@ -904,7 +907,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
     PL_regcode = r->program;
     /* Store the count of eval-groups for security checks: */
     PL_regcode->next_off = ((PL_seen_evals > U16_MAX) ? U16_MAX : PL_seen_evals);
-    regc((U8)REG_MAGIC, (char*) PL_regcode++);
+    REGC((U8)REG_MAGIC, (char*) PL_regcode++);
     r->data = 0;
     if (reg(0, &flags) == NULL)
 	return(NULL);
@@ -1953,8 +1956,7 @@ tryagain:
 	    ret = reg_node(FOLD
 			  ? (LOC ? EXACTFL : EXACTF)
 			  : EXACT);
-	    s = (char *) OPERAND(ret);
-	    regc(0, s++);		/* save spot for len */
+	    s = STRING(ret);
 	    for (len = 0, p = PL_regcomp_parse - 1;
 	      len < 127 && p < PL_regxend;
 	      len++)
@@ -2094,7 +2096,7 @@ tryagain:
 		    }
 		    else {
 			len++;
-			regc(ender, s++);
+			REGC(ender, s++);
 		    }
 		    break;
 		}
@@ -2104,7 +2106,7 @@ tryagain:
 		    len += numlen - 1;
 		}
 		else
-		    regc(ender, s++);
+		    REGC(ender, s++);
 	    }
 	loopdone:
 	    PL_regcomp_parse = p - 1;
@@ -2116,14 +2118,11 @@ tryagain:
 	    if (len == 1)
 		*flagp |= SIMPLE;
 	    if (!SIZE_ONLY)
-		*OPERAND(ret) = len;
-	    regc('\0', s++);
-	    if (SIZE_ONLY) {
-		PL_regsize += (len + 2 + sizeof(regnode) - 1) / sizeof(regnode);
-	    }
-	    else {
-		PL_regcode += (len + 2 + sizeof(regnode) - 1) / sizeof(regnode);
-	    }
+		STR_LEN(ret) = len;
+	    if (SIZE_ONLY)
+		PL_regsize += STR_SZ(len);
+	    else
+		PL_regcode += STR_SZ(len);
 	}
 	break;
     }
@@ -2303,10 +2302,10 @@ S_regclass(pTHX)
     I32 numlen;
     I32 namedclass;
 
-    s = opnd = (char *) OPERAND(PL_regcode);
+    s = opnd = MASK(PL_regcode);
     ret = reg_node(ANYOF);
     for (value = 0; value < ANYOF_SIZE; value++)
-	regc(0, s++);
+	REGC(0, s++);
     if (*PL_regcomp_parse == '^') {	/* Complement of range. */
 	PL_regnaughty++;
 	PL_regcomp_parse++;
@@ -2957,7 +2956,7 @@ S_reganode(pTHX_ U8 op, U32 arg)
 }
 
 /*
-- regc - emit (if appropriate) a Unicode character
+- reguni - emit (if appropriate) a Unicode character
 */
 STATIC void
 S_reguni(pTHX_ UV uv, char* s, I32* lenp)
@@ -2973,17 +2972,6 @@ S_reguni(pTHX_ UV uv, char* s, I32* lenp)
 }
 
 /*
-- regc - emit (if appropriate) a byte of code
-*/
-STATIC void
-S_regc(pTHX_ U8 b, char* s)
-{
-    dTHR;
-    if (!SIZE_ONLY)
-	*s = b;
-}
-
-/*
 - reginsert - insert an operator in front of already-emitted operand
 *
 * Means relocating the operand.
@@ -3144,7 +3132,7 @@ S_dumpuntil(pTHX_ regnode *start, regnode *node, regnode *last, SV* sv, I32 l)
 	}
 	else if (PL_regkind[(U8)op] == EXACT) {
             /* Literal string, where present. */
-	    node += ((*OPERAND(node)) + 2 + sizeof(regnode) - 1) / sizeof(regnode);
+	    node += NODE_SZ_STR(node) - 1;
 	    node = NEXTOPER(node);
 	}
 	else {
@@ -3247,7 +3235,8 @@ Perl_regprop(pTHX_ SV *sv, regnode *o)
     k = PL_regkind[(U8)OP(o)];
 
     if (k == EXACT)
-	Perl_sv_catpvf(aTHX_ sv, " <%s%s%s>", PL_colors[0], OPERAND(o) + 1, PL_colors[1]);
+	Perl_sv_catpvf(aTHX_ sv, " <%s%*s%s>", PL_colors[0],
+		       STR_LEN(o), STRING(o), PL_colors[1]);
     else if (k == CURLY) {
 	if (OP(o) == CURLYM || OP(o) == CURLYN)
 	    Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags); /* Parenth number */
diff --git a/regcomp.h b/regcomp.h
index 7bddc1b051..e30c8e7ca5 100644
--- a/regcomp.h
+++ b/regcomp.h
@@ -66,10 +66,10 @@ typedef OP OP_4tree;			/* Will be redefined later. */
  */
 
 struct regnode_string {
-    U8	flags;
+    U8	str_len;
     U8  type;
     U16 next_off;
-    U8 string[1];
+    char string[1];
 };
 
 struct regnode_1 {
@@ -133,6 +133,12 @@ struct regnode_2 {
 
 #define	OP(p)		((p)->type)
 #define	OPERAND(p)	(((struct regnode_string *)p)->string)
+#define MASK(p)		((char*)OPERAND(p))
+#define	STR_LEN(p)	(((struct regnode_string *)p)->str_len)
+#define	STRING(p)	(((struct regnode_string *)p)->string)
+#define STR_SZ(l)	((l + sizeof(regnode) - 1) / sizeof(regnode))
+#define NODE_SZ_STR(p)	(STR_SZ(STR_LEN(p))+1)
+
 #define	NODE_ALIGN(node)
 #define	ARG_LOC(p)	(((struct regnode_1 *)p)->arg1)
 #define	ARG1_LOC(p)	(((struct regnode_2 *)p)->arg1)
diff --git a/regexec.c b/regexec.c
index 6be77cc042..3fb1826e19 100644
--- a/regexec.c
+++ b/regexec.c
@@ -884,7 +884,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	/* We know what class it must start with. */
 	switch (OP(c)) {
 	case ANYOFUTF8:
-	    cc = (char *) OPERAND(c);
+	    cc = MASK(c);
 	    while (s < strend) {
 		if (REGINCLASSUTF8(c, (U8*)s)) {
 		    if (tmp && regtry(prog, s))
@@ -898,7 +898,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	    }
 	    break;
 	case ANYOF:
-	    cc = (char *) OPERAND(c);
+	    cc = MASK(c);
 	    while (s < strend) {
 		if (REGINCLASS(cc, *s)) {
 		    if (tmp && regtry(prog, s))
@@ -1697,8 +1697,8 @@ S_regmatch(pTHX_ regnode *prog)
 	    nextchr = UCHARAT(++locinput);
 	    break;
 	case EXACT:
-	    s = (char *) OPERAND(scan);
-	    ln = UCHARAT(s++);
+	    s = STRING(scan);
+	    ln = STR_LEN(scan);
 	    /* Inline the first character, for speed. */
 	    if (UCHARAT(s) != nextchr)
 		sayNO;
@@ -1713,8 +1713,8 @@ S_regmatch(pTHX_ regnode *prog)
 	    PL_reg_flags |= RF_tainted;
 	    /* FALL THROUGH */
 	case EXACTF:
-	    s = (char *) OPERAND(scan);
-	    ln = UCHARAT(s++);
+	    s = STRING(scan);
+	    ln = STR_LEN(scan);
 
 	    if (UTF) {
 		char *l = locinput;
@@ -1752,7 +1752,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    nextchr = UCHARAT(locinput);
 	    break;
 	case ANYOFUTF8:
-	    s = (char *) OPERAND(scan);
+	    s = MASK(scan);
 	    if (!REGINCLASSUTF8(scan, (U8*)locinput))
 		sayNO;
 	    if (locinput >= PL_regeol)
@@ -1761,7 +1761,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    nextchr = UCHARAT(locinput);
 	    break;
 	case ANYOF:
-	    s = (char *) OPERAND(scan);
+	    s = MASK(scan);
 	    if (nextchr < 0)
 		nextchr = UCHARAT(locinput);
 	    if (!REGINCLASS(s, nextchr))
@@ -2535,7 +2535,7 @@ S_regmatch(pTHX_ regnode *prog)
 		    ln = n;
 		locinput = PL_reginput;
 		if (PL_regkind[(U8)OP(next)] == EXACT) {
-		    c1 = UCHARAT(OPERAND(next) + 1);
+		    c1 = (U8)*STRING(next);
 		    if (OP(next) == EXACTF)
 			c2 = PL_fold[c1];
 		    else if (OP(next) == EXACTFL)
@@ -2592,7 +2592,7 @@ S_regmatch(pTHX_ regnode *prog)
 		    );
 		if (n >= ln) {
 		    if (PL_regkind[(U8)OP(next)] == EXACT) {
-			c1 = UCHARAT(OPERAND(next) + 1);
+			c1 = (U8)*STRING(next);
 			if (OP(next) == EXACTF)
 			    c2 = PL_fold[c1];
 			else if (OP(next) == EXACTFL)
@@ -2669,7 +2669,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    * when we know what character comes next.
 	    */
 	    if (PL_regkind[(U8)OP(next)] == EXACT) {
-		c1 = UCHARAT(OPERAND(next) + 1);
+		c1 = (U8)*STRING(next);
 		if (OP(next) == EXACTF)
 		    c2 = PL_fold[c1];
 		else if (OP(next) == EXACTFL)
@@ -2975,7 +2975,6 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
     scan = PL_reginput;
     if (max != REG_INFTY && max < loceol - scan)
       loceol = scan + max;
-    opnd = (char *) OPERAND(p);
     switch (OP(p)) {
     case REG_ANY:
 	while (scan < loceol && *scan != '\n')
@@ -2999,19 +2998,19 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
 	}
 	break;
     case EXACT:		/* length of string is 1 */
-	c = UCHARAT(++opnd);
+	c = (U8)*STRING(p);
 	while (scan < loceol && UCHARAT(scan) == c)
 	    scan++;
 	break;
     case EXACTF:	/* length of string is 1 */
-	c = UCHARAT(++opnd);
+	c = (U8)*STRING(p);
 	while (scan < loceol &&
 	       (UCHARAT(scan) == c || UCHARAT(scan) == PL_fold[c]))
 	    scan++;
 	break;
     case EXACTFL:	/* length of string is 1 */
 	PL_reg_flags |= RF_tainted;
-	c = UCHARAT(++opnd);
+	c = (U8)*STRING(p);
 	while (scan < loceol &&
 	       (UCHARAT(scan) == c || UCHARAT(scan) == PL_fold_locale[c]))
 	    scan++;
@@ -3024,6 +3023,7 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
 	}
 	break;
     case ANYOF:
+	opnd = MASK(p);
 	while (scan < loceol && REGINCLASS(opnd, *scan))
 	    scan++;
 	break;