 @@ -1,14 +1,14 @@
-/*	$NetBSD: engine.c,v 1.2 2008/12/05 22:51:43 christos Exp $ */
+/*	$NetBSD: engine.c,v 1.3 2009/01/02 00:32:11 tnozaki Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -320,40 +320,40 @@ sopno stopst;
 	register RCHAR_T *tail;	/* string unmatched by rest of RE */
 	register sopno ssub;	/* start sop of subsubRE */
 	register sopno esub;	/* end sop of subsubRE */
 	register RCHAR_T *ssp;	/* start of string matched by subsubRE */
 	register RCHAR_T *sep;	/* end of string matched by subsubRE */
 	register RCHAR_T *oldssp;	/* previous ssp */
 	register RCHAR_T *dp;
 	AT("diss", start, stop, startst, stopst);
 	sp = start;
 	for (ss = startst; ss < stopst; ss = es) {
 		/* identify end of subRE */
 		es = ss;
-		switch (OP(m->g->strip[es])) {
+		switch (m->g->strip[es]) {
 		case OPLUS_:
 		case OQUEST_:
-			es += OPND(m->g->strip[es]);
+			es += m->g->stripdata[es];
 			break;
 		case OCH_:
-			while (OP(m->g->strip[es]) != O_CH)
+			while (m->g->strip[es] != O_CH)
-				es += OPND(m->g->strip[es]);
+				es += m->g->stripdata[es];
 			break;
+		}
 		es++;
 		/* figure out what it matched */
-		switch (OP(m->g->strip[ss])) {
+		switch (m->g->strip[ss]) {
 		case OEND:
 			assert(nope);
 			break;
 		case OCHAR:
 			sp++;
 			break;
 		case OBOL:
 		case OEOL:
 		case OBOW:
 		case OEOW:
 			break;
 		case OANY:
 		case OANYOF:
 @@ -429,60 +429,60 @@ sopno stopst;
 			for (;;) {
 				/* how long could this one be? */
 				rest = slow(m, sp, stp, ss, es);
 				assert(rest != NULL);	/* it did match */
 				/* could the rest match the rest? */
 				tail = slow(m, rest, stop, es, stopst);
 				if (tail == stop)
 					break;		/* yes! */
 				/* no -- try a shorter match for this one */
 				stp = rest - 1;
 				assert(stp >= sp);	/* it did work */
+			}
 			ssub = ss + 1;
-			esub = ss + OPND(m->g->strip[ss]) - 1;
+			esub = ss + m->g->stripdata[ss] - 1;
-			assert(OP(m->g->strip[esub]) == OOR1);
+			assert(m->g->strip[esub] == OOR1);
 			for (;;) {	/* find first matching branch */
 				if (slow(m, sp, rest, ssub, esub) == rest)
 					break;	/* it matched all of it */
 				/* that one missed, try next one */
-				assert(OP(m->g->strip[esub]) == OOR1);
+				assert(m->g->strip[esub] == OOR1);
 				esub++;
-				assert(OP(m->g->strip[esub]) == OOR2);
+				assert(m->g->strip[esub] == OOR2);
 				ssub = esub + 1;
-				esub += OPND(m->g->strip[esub]);
+				esub += m->g->stripdata[esub];
-				if (OP(m->g->strip[esub]) == OOR2)
+				if (m->g->strip[esub] == OOR2)
 					esub--;
 				else
-					assert(OP(m->g->strip[esub]) == O_CH);
+					assert(m->g->strip[esub] == O_CH);
+			}
 			dp = dissect(m, sp, rest, ssub, esub);
 			assert(dp == rest);
 			sp = rest;
 			break;
 		case O_PLUS:
 		case O_QUEST:
 		case OOR1:
 		case OOR2:
 		case O_CH:
 			assert(nope);
 			break;
 		case OLPAREN:
-			i = OPND(m->g->strip[ss]);
+			i = m->g->stripdata[ss];
 			assert(0 < i && i <= m->g->nsub);
 			m->pmatch[i].rm_so = sp - m->offp;
 			break;
 		case ORPAREN:
-			i = OPND(m->g->strip[ss]);
+			i = m->g->stripdata[ss];
 			assert(0 < i && i <= m->g->nsub);
 			m->pmatch[i].rm_eo = sp - m->offp;
 			break;
 		default:		/* uh oh */
 			assert(nope);
 			break;
+		}
+	}
 	assert(sp == stop);
 	return(sp);
+}
 @@ -500,47 +500,50 @@ sopno startst;
 sopno stopst;
 sopno lev;			/* PLUS nesting level */
+{
 	register int i;
 	register sopno ss;	/* start sop of current subRE */
 	register RCHAR_T *sp;	/* start of string matched by it */
 	register sopno ssub;	/* start sop of subsubRE */
 	register sopno esub;	/* end sop of subsubRE */
 	register RCHAR_T *ssp;	/* start of string matched by subsubRE */
 	register RCHAR_T *dp;
 	register size_t len;
 	register int hard;
 	register sop s;
 	register RCHAR_T d;
 	register regoff_t offsave;
 	register cset *cs;
 	AT("back", start, stop, startst, stopst);
 	sp = start;
 	/* get as far as we can with easy stuff */
 	hard = 0;
-	for (ss = startst; !hard && ss < stopst; ss++)
+	for (ss = startst; !hard && ss < stopst; ss++) {
-		switch (OP(s = m->g->strip[ss])) {
+		s = m->g->strip[ss];
 		d = m->g->stripdata[ss];
 		switch (s) {
 		case OCHAR:
-			if (sp == stop || *sp++ != (RCHAR_T)OPND(s))
+			if (sp == stop || *sp++ != d)
 				return(NULL);
 			break;
 		case OANY:
 			if (sp == stop)
 				return(NULL);
 			sp++;
 			break;
 		case OANYOF:
-			cs = &m->g->sets[OPND(s)];
+			cs = &m->g->sets[d];
 			if (sp == stop || !CHIN(cs, *sp++))
 				return(NULL);
 			break;
 		case OBOL:
 			if ( (sp == m->beginp && !(m->eflags&REG_NOTBOL)) ||
 					(sp < m->endp && *(sp-1) == '\n' &&
 						(m->g->cflags&REG_NEWLINE)) )
 				{ /* yes */ }
 			else
 				return(NULL);
 			break;
 		case OEOL:
 			if ( (sp == m->endp && !(m->eflags&REG_NOTEOL)) ||
 @@ -566,121 +569,126 @@ sopno lev;			/* PLUS nesting level */
 					(sp < m->endp && *sp == '\n' &&
 						(m->g->cflags&REG_NEWLINE)) ||
 					(sp < m->endp && !ISWORD(*sp)) ) &&
 					(sp > m->beginp && ISWORD(*(sp-1))) )
 				{ /* yes */ }
 			else
 				return(NULL);
 			break;
 		case O_QUEST:
 			break;
 		case OOR1:	/* matches null but needs to skip */
 			ss++;
 			s = m->g->strip[ss];
 			d = m->g->stripdata[ss];
 			do {
-				assert(OP(s) == OOR2);
+				assert(s == OOR2);
-				ss += OPND(s);
+				ss += d;
-			} while (OP(s = m->g->strip[ss]) != O_CH);
+				s = m->g->strip[ss];
 				d = m->g->stripdata[ss];
 			} while (s != O_CH);
 			/* note that the ss++ gets us past the O_CH */
 			break;
 		default:	/* have to make a choice */
 			hard = 1;
 			break;
+		}
+	}
 	if (!hard) {		/* that was it! */
 		if (sp != stop)
 			return(NULL);
 		return(sp);
+	}
 	ss--;			/* adjust for the for's final increment */
 	/* the hard stuff */
 	AT("hard", sp, stop, ss, stopst);
 	s = m->g->strip[ss];
-	switch (OP(s)) {
+	d = m->g->stripdata[ss];
 	switch (s) {
 	case OBACK_:		/* the vilest depths */
-		i = OPND(s);
+		i = d;
 		assert(0 < i && i <= m->g->nsub);
 		if (m->pmatch[i].rm_eo == -1)
 			return(NULL);
 		assert(m->pmatch[i].rm_so != -1);
 		len = m->pmatch[i].rm_eo - m->pmatch[i].rm_so;
 		assert(stop - m->beginp >= len);
 		if (sp > stop - len)
 			return(NULL);	/* not enough left to match */
 		ssp = m->offp + m->pmatch[i].rm_so;
 		if (memcmp(sp, ssp, len) != 0)
 			return(NULL);
-		while (m->g->strip[ss] != SOP(O_BACK, i))
+		while (m->g->strip[ss] != O_BACK || m->g->stripdata[ss] != i)
 			ss++;
 		return(backref(m, sp+len, stop, ss+1, stopst, lev));
 		break;
 	case OQUEST_:		/* to null or not */
 		dp = backref(m, sp, stop, ss+1, stopst, lev);
 		if (dp != NULL)
 			return(dp);	/* not */
-		return(backref(m, sp, stop, ss+OPND(s)+1, stopst, lev));
+		return(backref(m, sp, stop, ss+d+1, stopst, lev));
 		break;
 	case OPLUS_:
 		assert(m->lastpos != NULL);
 		assert(lev+1 <= m->g->nplus);
 		m->lastpos[lev+1] = sp;
 		return(backref(m, sp, stop, ss+1, stopst, lev+1));
 		break;
 	case O_PLUS:
 		if (sp == m->lastpos[lev])	/* last pass matched null */
 			return(backref(m, sp, stop, ss+1, stopst, lev-1));
 		/* try another pass */
 		m->lastpos[lev] = sp;
-		dp = backref(m, sp, stop, ss-OPND(s)+1, stopst, lev);
+		dp = backref(m, sp, stop, ss-d+1, stopst, lev);
 		if (dp == NULL)
 			return(backref(m, sp, stop, ss+1, stopst, lev-1));
 		else
 			return(dp);
 		break;
 	case OCH_:		/* find the right one, if any */
 		ssub = ss + 1;
-		esub = ss + OPND(s) - 1;
+		esub = ss + d - 1;
-		assert(OP(m->g->strip[esub]) == OOR1);
+		assert(m->g->strip[esub] == OOR1);
 		for (;;) {	/* find first matching branch */
 			dp = backref(m, sp, stop, ssub, esub, lev);
 			if (dp != NULL)
 				return(dp);
 			/* that one missed, try next one */
-			if (OP(m->g->strip[esub]) == O_CH)
+			if (m->g->strip[esub] == O_CH)
 				return(NULL);	/* there is none */
 			esub++;
-			assert(OP(m->g->strip[esub]) == OOR2);
+			assert(m->g->strip[esub] == OOR2);
 			ssub = esub + 1;
-			esub += OPND(m->g->strip[esub]);
+			esub += m->g->stripdata[esub];
-			if (OP(m->g->strip[esub]) == OOR2)
+			if (m->g->strip[esub] == OOR2)
 				esub--;
 			else
-				assert(OP(m->g->strip[esub]) == O_CH);
+				assert(m->g->strip[esub] == O_CH);
+		}
 		break;
 	case OLPAREN:		/* must undo assignment if rest fails */
-		i = OPND(s);
+		i = d;
 		assert(0 < i && i <= m->g->nsub);
 		offsave = m->pmatch[i].rm_so;
 		m->pmatch[i].rm_so = sp - m->offp;
 		dp = backref(m, sp, stop, ss+1, stopst, lev);
 		if (dp != NULL)
 			return(dp);
 		m->pmatch[i].rm_so = offsave;
 		return(NULL);
 		break;
 	case ORPAREN:		/* must undo assignment if rest fails */
-		i = OPND(s);
+		i = d;
 		assert(0 < i && i <= m->g->nsub);
 		offsave = m->pmatch[i].rm_eo;
 		m->pmatch[i].rm_eo = sp - m->offp;
 		dp = backref(m, sp, stop, ss+1, stopst, lev);
 		if (dp != NULL)
 			return(dp);
 		m->pmatch[i].rm_eo = offsave;
 		return(NULL);
 		break;
 	default:		/* uh oh */
 		assert(nope);
 		break;
+	}
 @@ -884,115 +892,120 @@ sopno stopst;
  == #define	NNONCHAR	(CODEMAX-CHAR_MAX)
  */
 static states
 step(g, start, stop, bef, ch, aft)
 register struct re_guts *g;
 sopno start;			/* start state within strip */
 sopno stop;			/* state after stop state within strip */
 register states bef;		/* states reachable before */
 int ch;				/* character or NONCHAR code */
 register states aft;		/* states already known reachable after */
+{
 	register cset *cs;
 	register sop s;
 	register RCHAR_T d;
 	register sopno pc;
 	register onestate here;		/* note, macros know this name */
 	register sopno look;
 	register int i;
 	for (pc = start, INIT(here, pc); pc != stop; pc++, INC(here)) {
 		s = g->strip[pc];
-		switch (OP(s)) {
+		d = g->stripdata[pc];
 		switch (s) {
 		case OEND:
 			assert(pc == stop-1);
 			break;
 		case OCHAR:
 			/* only characters can match */
-			assert(!NONCHAR(ch) || ch != (RCHAR_T)OPND(s));
+			assert(!NONCHAR(ch) || ch != d);
-			if (ch == (RCHAR_T)OPND(s))
+			if (ch == d)
 				FWD(aft, bef, 1);
 			break;
 		case OBOL:
 			if (ch == BOL || ch == BOLEOL)
 				FWD(aft, bef, 1);
 			break;
 		case OEOL:
 			if (ch == EOL || ch == BOLEOL)
 				FWD(aft, bef, 1);
 			break;
 		case OBOW:
 			if (ch == BOW)
 				FWD(aft, bef, 1);
 			break;
 		case OEOW:
 			if (ch == EOW)
 				FWD(aft, bef, 1);
 			break;
 		case OANY:
 			if (!NONCHAR(ch))
 				FWD(aft, bef, 1);
 			break;
 		case OANYOF:
-			cs = &g->sets[OPND(s)];
+			cs = &g->sets[d];
 			if (!NONCHAR(ch) && CHIN(cs, ch))
 				FWD(aft, bef, 1);
 			break;
 		case OBACK_:		/* ignored here */
 		case O_BACK:
 			FWD(aft, aft, 1);
 			break;
 		case OPLUS_:		/* forward, this is just an empty */
 			FWD(aft, aft, 1);
 			break;
 		case O_PLUS:		/* both forward and back */
 			FWD(aft, aft, 1);
-			i = ISSETBACK(aft, OPND(s));
+			i = ISSETBACK(aft, d);
-			BACK(aft, aft, OPND(s));
+			BACK(aft, aft, d);
-			if (!i && ISSETBACK(aft, OPND(s))) {
+			if (!i && ISSETBACK(aft, d)) {
 				/* oho, must reconsider loop body */
-				pc -= OPND(s) + 1;
+				pc -= d + 1;
 				INIT(here, pc);
+			}
 			break;
 		case OQUEST_:		/* two branches, both forward */
 			FWD(aft, aft, 1);
-			FWD(aft, aft, OPND(s));
+			FWD(aft, aft, d);
 			break;
 		case O_QUEST:		/* just an empty */
 			FWD(aft, aft, 1);
 			break;
 		case OLPAREN:		/* not significant here */
 		case ORPAREN:
 			FWD(aft, aft, 1);
 			break;
 		case OCH_:		/* mark the first two branches */
 			FWD(aft, aft, 1);
-			assert(OP(g->strip[pc+OPND(s)]) == OOR2);
+			assert(OP(g->strip[pc+d]) == OOR2);
-			FWD(aft, aft, OPND(s));
+			FWD(aft, aft, d);
 			break;
 		case OOR1:		/* done a branch, find the O_CH */
 			if (ISSTATEIN(aft, here)) {
-				for (look = 1;
+				for (look = 1; /**/; look += d) {
-						OP(s = g->strip[pc+look]) != O_CH;
+					s = g->strip[pc+look];
-						look += OPND(s))
+					d = g->stripdata[pc+look];
-					assert(OP(s) == OOR2);
+					if (s == O_CH)
 						break;
 					assert(s == OOR2);
+				}
 				FWD(aft, aft, look);
+			}
 			break;
 		case OOR2:		/* propagate OCH_'s marking */
 			FWD(aft, aft, 1);
-			if (OP(g->strip[pc+OPND(s)]) != O_CH) {
+			if (g->strip[pc+d] != O_CH) {
-				assert(OP(g->strip[pc+OPND(s)]) == OOR2);
+				assert(g->strip[pc+d] == OOR2);
-				FWD(aft, aft, OPND(s));
+				FWD(aft, aft, d);
+			}
 			break;
 		case O_CH:		/* just empty */
 			FWD(aft, aft, 1);
 			break;
 		default:		/* ooooops... */
 			assert(nope);
 			break;
+		}
+	}
 	return(aft);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: regcomp.c,v 1.2 2008/12/05 22:51:43 christos Exp $ */
+/*	$NetBSD: regcomp.c,v 1.3 2009/01/02 00:32:11 tnozaki Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -56,26 +56,27 @@ static char sccsid[] = "@(#)regcomp.c	8.
 #include "cclass.h"
 #include "cname.h"
 /*
  * parse structure, passed up and down to avoid global variables and
  * other clumsinesses
  */
 struct parse {
 	RCHAR_T *next;		/* next character in RE */
 	RCHAR_T *end;		/* end of string (-> NUL normally) */
 	int error;		/* has an error been seen? */
 	sop *strip;		/* malloced strip */
 	RCHAR_T *stripdata;	/* malloced stripdata */
 	sopno ssize;		/* malloced strip size (allocated) */
 	sopno slen;		/* malloced strip length (used) */
 	int ncsalloc;		/* number of csets allocated */
 	struct re_guts *g;
 #	define	NPAREN	10	/* we need to remember () 1-9 for back refs */
 	sopno pbegin[NPAREN];	/* -> ( ([0] unused) */
 	sopno pend[NPAREN];	/* -> ) ([0] unused) */
 };
 /* ========= begin header generated by ./mkh ========= */
 #ifdef __cplusplus
 extern "C" {
 #endif
 @@ -203,31 +204,37 @@ regcomp(regex_t *preg, const RCHAR_T *pa
 		if (preg->re_endp < pattern)
 			return(REG_INVARG);
 		len = preg->re_endp - pattern;
 	} else
 		len = STRLEN(pattern);
 	/* do the mallocs early so failure handling is easy */
 	g = (struct re_guts *)malloc(sizeof(struct re_guts) +
 							(NC-1)*sizeof(cat_t));
 	if (g == NULL)
 		return(REG_ESPACE);
 	p->ssize = len/(size_t)2*(size_t)3 + (size_t)1;	/* ugh */
 	p->strip = (sop *)malloc(p->ssize * sizeof(sop));
 	p->slen = 0;
 	if (p->strip == NULL) {
 		free((char *)g);
 		return(REG_ESPACE);
+	}
 	p->stripdata = (RCHAR_T *)malloc(p->ssize * sizeof(RCHAR_T));
 	if (p->stripdata == NULL) {
 		free((char *)p->strip);
 		free((char *)g);
 		return(REG_ESPACE);
+	}
 	p->slen = 0;
 	/* set things up */
 	p->g = g;
 	p->next = (RCHAR_T *)__UNCONST(pattern);	/* convenience; we do not modify it */
 	p->end = p->next + len;
 	p->error = 0;
 	p->ncsalloc = 0;
 	for (i = 0; i < NPAREN; i++) {
 		p->pbegin[i] = 0;
 		p->pend[i] = 0;
+	}
 	g->csetsize = NC;
 	g->sets = NULL;
 @@ -532,98 +539,103 @@ p_bre(register struct parse *p, register
  == static int p_simp_re(register struct parse *p, int starordinary);
  */
 static int			/* was the simple RE an unbackslashed $? */
 p_simp_re(register struct parse *p, int starordinary)
                  		/* is a leading * an ordinary character? */
+{
 	register int c;
 	register int count;
 	register int count2;
 	register sopno pos;
 	register int i;
 	register sopno subno;
 #	define	BACKSL	(1<<RCHAR_BIT)
 	pos = HERE();		/* repetion op, if any, covers from here */
 	assert(MORE());		/* caller should have ensured this */
 	c = GETNEXT();
 	if (c == '\\') {
 		(void)REQUIRE(MORE(), REG_EESCAPE);
-		c = BACKSL | (unsigned char)GETNEXT();
+		c = (unsigned char)GETNEXT();
 		switch (c) {
-	switch (c) {
+		case '{':
-	case '.':
+			SETERROR(REG_BADRPT);
-		if (p->g->cflags&REG_NEWLINE)
+			break;
-			nonnewline(p);
+		case '(':
-		else
+			p->g->nsub++;
-			EMIT(OANY, 0);
+			subno = p->g->nsub;
-		break;
+			if (subno < NPAREN)
-	case '[':
+				p->pbegin[subno] = HERE();
-		p_bracket(p);
+			EMIT(OLPAREN, subno);
-		break;
+			/* the MORE here is an error heuristic */
-	case BACKSL|'{':
+			if (MORE() && !SEETWO('\\', ')'))
-		SETERROR(REG_BADRPT);
+				p_bre(p, '\\', ')');
-		break;
+			if (subno < NPAREN) {
-	case BACKSL|'(':
+				p->pend[subno] = HERE();
-		p->g->nsub++;
+				assert(p->pend[subno] != 0);
 		subno = p->g->nsub;
-		if (subno < NPAREN)
+			EMIT(ORPAREN, subno);
-			p->pbegin[subno] = HERE();
+			(void)REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
-		EMIT(OLPAREN, subno);
+			break;
-		/* the MORE here is an error heuristic */
+		case ')':	/* should not get here -- must be user */
-		if (MORE() && !SEETWO('\\', ')'))
+		case '}':
-			p_bre(p, '\\', ')');
+			SETERROR(REG_EPAREN);
-		if (subno < NPAREN) {
+			break;
-			p->pend[subno] = HERE();
+		case '1':
-			assert(p->pend[subno] != 0);
+		case '2':
 		case '3':
 		case '4':
 		case '5':
 		case '6':
 		case '7':
 		case '8':
 		case '9':
 			i = c - '0';
 			assert(i < NPAREN);
 			if (p->pend[i] != 0) {
 				assert(i <= p->g->nsub);
 				EMIT(OBACK_, i);
 				assert(p->pbegin[i] != 0);
 				assert(p->strip[p->pbegin[i]] == OLPAREN);
 				assert(p->strip[p->pend[i]] == ORPAREN);
 				(void) dupl(p, p->pbegin[i]+1, p->pend[i]);
 				EMIT(O_BACK, i);
 			} else
 				SETERROR(REG_ESUBREG);
 			p->g->backrefs = 1;
 			break;
 		default:
 			ordinary(p, c);
 			break;
+		}
 	} else {
 		switch (c) {
 		case '.':
 			if (p->g->cflags&REG_NEWLINE)
 				nonnewline(p);
 			else
 				EMIT(OANY, 0);
 			break;
 		case '[':
 			p_bracket(p);
 			break;
 		case '*':
 			(void)REQUIRE(starordinary, REG_BADRPT);
 			/* FALLTHROUGH */
 		default:
 			ordinary(p, c);
 			break;
+		}
 		EMIT(ORPAREN, subno);
 		(void)REQUIRE(EATTWO('\\', ')'), REG_EPAREN);
 		break;
 	case BACKSL|')':	/* should not get here -- must be user */
 	case BACKSL|'}':
 		SETERROR(REG_EPAREN);
 		break;
 	case BACKSL|'1':
 	case BACKSL|'2':
 	case BACKSL|'3':
 	case BACKSL|'4':
 	case BACKSL|'5':
 	case BACKSL|'6':
 	case BACKSL|'7':
 	case BACKSL|'8':
 	case BACKSL|'9':
 		i = (c&~BACKSL) - '0';
 		assert(i < NPAREN);
 		if (p->pend[i] != 0) {
 			assert(i <= p->g->nsub);
 			EMIT(OBACK_, i);
 			assert(p->pbegin[i] != 0);
 			assert(OP(p->strip[p->pbegin[i]]) == OLPAREN);
 			assert(OP(p->strip[p->pend[i]]) == ORPAREN);
 			(void) dupl(p, p->pbegin[i]+1, p->pend[i]);
 			EMIT(O_BACK, i);
 		} else
 			SETERROR(REG_ESUBREG);
 		p->g->backrefs = 1;
 		break;
 	case '*':
 		(void)REQUIRE(starordinary, REG_BADRPT);
 		/* FALLTHROUGH */
 	default:
 		ordinary(p, c &~ BACKSL);
 		break;
+	}
 	if (EAT('*')) {		/* implemented as +? */
 		/* this case does not require the (y|) trick, noKLUDGE */
 		INSERT(OPLUS_, pos);
 		ASTERN(O_PLUS, pos);
 		INSERT(OQUEST_, pos);
 		ASTERN(O_QUEST, pos);
 	} else if (EATTWO('\\', '{')) {
 		count = p_count(p);
 		if (EAT(',')) {
 			if (MORE() && isdigit(PEEK())) {
 				count2 = p_count(p);
 @@ -1399,249 +1411,288 @@ dupl(register struct parse *p, sopno sta
             			/* from here */
              			/* to this less one */
+{
 	register sopno ret = HERE();
 	register sopno len = finish - start;
 	assert(finish >= start);
 	if (len == 0)
 		return(ret);
 	enlarge(p, p->ssize + len);	/* this many unexpected additions */
 	assert(p->ssize >= p->slen + len);
 	(void) memcpy((char *)(p->strip + p->slen),
 		(char *)(p->strip + start), (size_t)len*sizeof(sop));
 	(void) memcpy((char *)(p->stripdata + p->slen),
 		(char *)(p->stripdata + start), (size_t)len*sizeof(RCHAR_T));
 	p->slen += len;
 	return(ret);
+}
 /*
  - doemit - emit a strip operator
  == static void doemit(register struct parse *p, sop op, size_t opnd);
+ *
  * It might seem better to implement this as a macro with a function as
  * hard-case backup, but it's just too big and messy unless there are
  * some changes to the data structures.  Maybe later.
  */
 static void
 doemit(register struct parse *p, sop op, size_t opnd)
+{
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 	/* deal with oversize operands ("can't happen", more or less) */
-	assert(opnd < 1<<OPSHIFT);
+	assert(opnd < 1);
 	/* deal with undersized strip */
 	if (p->slen >= p->ssize)
 		enlarge(p, (p->ssize+1) / 2 * 3);	/* +50% */
 	assert(p->slen < p->ssize);
 	/* finally, it's all reduced to the easy case */
-	p->strip[p->slen++] = SOP(op, opnd);
+	p->strip[p->slen] = op;
 	p->stripdata[p->slen] = opnd;
 	p->slen++;
+}
 /*
  - doinsert - insert a sop into the strip
  == static void doinsert(register struct parse *p, sop op, size_t opnd, sopno pos);
  */
 static void
 doinsert(register struct parse *p, sop op, size_t opnd, sopno pos)
+{
 	register sopno sn;
 	register sop s;
 	register RCHAR_T d;
 	register int i;
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 	sn = HERE();
 	EMIT(op, opnd);		/* do checks, ensure space */
 	assert(HERE() == sn+1);
 	s = p->strip[sn];
 	d = p->stripdata[sn];
 	/* adjust paren pointers */
 	assert(pos > 0);
 	for (i = 1; i < NPAREN; i++) {
 		if (p->pbegin[i] >= pos) {
 			p->pbegin[i]++;
+		}
 		if (p->pend[i] >= pos) {
 			p->pend[i]++;
+		}
+	}
 	memmove((char *)&p->strip[pos+1], (char *)&p->strip[pos],
 						(HERE()-pos-1)*sizeof(sop));
 	memmove((char *)&p->stripdata[pos+1], (char *)&p->stripdata[pos],
 						(HERE()-pos-1)*sizeof(RCHAR_T));
 	p->strip[pos] = s;
 	p->stripdata[pos] = d;
+}
 /*
  - dofwd - complete a forward reference
  == static void dofwd(register struct parse *p, sopno pos, sop value);
  */
 static void
 dofwd(register struct parse *p, register sopno pos, sop value)
+{
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
-	assert(value < 1<<OPSHIFT);
+	assert(value < 1);
-	p->strip[pos] = OP(p->strip[pos]) | value;
+	p->stripdata[pos] = value;
+}
 /*
  - enlarge - enlarge the strip
  == static void enlarge(register struct parse *p, sopno size);
  */
 static void
 enlarge(register struct parse *p, register sopno size)
+{
 	register sop *sp;
 	register RCHAR_T *dp;
 	if (p->ssize >= size)
 		return;
 	sp = (sop *)realloc(p->strip, size*sizeof(sop));
 	if (sp == NULL) {
 		SETERROR(REG_ESPACE);
 		return;
+	}
 	p->strip = sp;
 	dp = (RCHAR_T *)realloc(p->stripdata, size*sizeof(RCHAR_T));
 	if (dp == NULL) {
 		SETERROR(REG_ESPACE);
 		return;
+	}
 	p->stripdata = dp;
 	p->ssize = size;
+}
 /*
  - stripsnug - compact the strip
  == static void stripsnug(register struct parse *p, register struct re_guts *g);
  */
 static void
 stripsnug(register struct parse *p, register struct re_guts *g)
+{
 	g->nstates = p->slen;
-	g->strip = (sop *)realloc((char *)p->strip, p->slen * sizeof(sop));
+	g->strip = (sop *)realloc((char *)p->strip,
 	    p->slen * sizeof(sop));
 	if (g->strip == NULL) {
 		SETERROR(REG_ESPACE);
 		g->strip = p->strip;
+	}
 	g->stripdata = (RCHAR_T *)realloc((char *)p->stripdata,
 	    p->slen * sizeof(RCHAR_T));
 	if (g->stripdata == NULL) {
 		SETERROR(REG_ESPACE);
 		g->stripdata = p->stripdata;
+	}
+}
 /*
  - findmust - fill in must and mlen with longest mandatory literal string
  == static void findmust(register struct parse *p, register struct re_guts *g);
+ *
  * This algorithm could do fancy things like analyzing the operands of |
  * for common subsequences.  Someday.  This code is simple and finds most
  * of the interesting cases.
+ *
  * Note that must and mlen got initialized during setup.
  */
 static void
 findmust(struct parse *p, register struct re_guts *g)
+{
-	register sop *scan;
+	register sop *scans;
-	sop *start = 0;
+	register RCHAR_T *scand;
-	register sop *newstart = 0;
+	sop *starts = 0;
 	RCHAR_T *startd = NULL;
 	register sop *newstarts = 0;
 	register RCHAR_T *newstartd = NULL;
 	register sopno newlen;
 	register sop s;
 	register RCHAR_T d;
 	register RCHAR_T *cp;
 	register sopno i;
 	/* avoid making error situations worse */
 	if (p->error != 0)
 		return;
 	/* find the longest OCHAR sequence in strip */
 	newlen = 0;
-	scan = g->strip + 1;
+	scans = g->strip + 1;
 	scand = g->stripdata + 1;
 	do {
-		s = *scan++;
+		s = *scans++;
-		switch (OP(s)) {
+		d = *scand++;
 		switch (s) {
 		case OCHAR:		/* sequence member */
-			if (newlen == 0)		/* new sequence */
+			if (newlen == 0) {		/* new sequence */
-				newstart = scan - 1;
+				newstarts = scans - 1;
 				newstartd = scand - 1;
+			}
 			newlen++;
 			break;
 		case OPLUS_:		/* things that don't break one */
 		case OLPAREN:
 		case ORPAREN:
 			break;
 		case OQUEST_:		/* things that must be skipped */
 		case OCH_:
-			scan--;
+			scans--;
 			scand--;
 			do {
-				scan += OPND(s);
+				scans += d;
-				s = *scan;
+				scand += d;
 				s = *scans;
 				d = *scand;
 				/* assert() interferes w debug printouts */
-				if (OP(s) != O_QUEST && OP(s) != O_CH &&
+				if (s != O_QUEST && s != O_CH && s != OOR2) {
 							OP(s) != OOR2) {
 					g->iflags |= BAD;
 					return;
+				}
-			} while (OP(s) != O_QUEST && OP(s) != O_CH);
+			} while (s != O_QUEST && s != O_CH);
 			/* fallthrough */
 		default:		/* things that break a sequence */
 			if (newlen > g->mlen) {		/* ends one */
-				start = newstart;
+				starts = newstarts;
 				startd = newstartd;
 				g->mlen = newlen;
+			}
 			newlen = 0;
 			break;
+		}
-	} while (OP(s) != OEND);
+	} while (s != OEND);
 	if (g->mlen == 0)		/* there isn't one */
 		return;
 	/* turn it into a character string */
 	g->must = malloc(((size_t)g->mlen + 1) * sizeof(RCHAR_T));
 	if (g->must == NULL) {		/* argh; just forget it */
 		g->mlen = 0;
 		return;
+	}
 	cp = g->must;
-	scan = start;
+	scans = starts;
 	scand = startd;
 	for (i = g->mlen; i > 0; i--) {
-		while (OP(s = *scan++) != OCHAR)
+		for (;;) {
-			continue;
+			s = *scans++;
 			d = *scand++;
 			if (s == OCHAR)
 				break;
+		}
 		assert(cp < g->must + g->mlen);
-		*cp++ = (RCHAR_T)OPND(s);
+		*cp++ = d;
+	}
 	assert(cp == g->must + g->mlen);
 	*cp++ = '\0';		/* just on general principles */
+}
 /*
  - pluscount - count + nesting
  == static sopno pluscount(register struct parse *p, register struct re_guts *g);
  */
 static sopno			/* nesting depth */
 pluscount(struct parse *p, register struct re_guts *g)
+{
 	register sop *scan;
 	register sop s;
 	register sopno plusnest = 0;
 	register sopno maxnest = 0;
 	if (p->error != 0)
 		return(0);	/* there may not be an OEND */
 	scan = g->strip + 1;
 	do {
 		s = *scan++;
-		switch (OP(s)) {
+		switch (s) {
 		case OPLUS_:
 			plusnest++;
 			break;
 		case O_PLUS:
 			if (plusnest > maxnest)
 				maxnest = plusnest;
 			plusnest--;
 			break;
+		}
-	} while (OP(s) != OEND);
+	} while (s != OEND);
 	if (plusnest != 0)
 		g->iflags |= BAD;
 	return(maxnest);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: regex2.h,v 1.1.1.2 2008/05/18 14:31:38 aymeric Exp $ */
+/*	$NetBSD: regex2.h,v 1.2 2009/01/02 00:32:11 tnozaki Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -67,56 +67,50 @@
  * flow must be marked at both its source and its destination.  Some
  * fine points:
+ *
  * - OPLUS_ and O_PLUS are *inside* the loop they create.
  * - OQUEST_ and O_QUEST are *outside* the bypass they create.
  * - OCH_ and O_CH are *outside* the multi-way branch they create, while
  *   OOR1 and OOR2 are respectively the end and the beginning of one of
  *   the branches.  Note that there is an implicit OOR2 following OCH_
  *   and an implicit OOR1 preceding O_CH.
+ *
  * In state representations, an operator's bit is on to signify a state
  * immediately *preceding* "execution" of that operator.
  */
-typedef unsigned long sop;	/* strip operator */
+typedef char sop;	/* strip operator */
 typedef int sopno;
 #define	OPRMASK	0xf8000000
 #define	OPDMASK	0x07ffffff
 #define	OPSHIFT	((unsigned)27)
 #define	OP(n)	((n)&OPRMASK)
 #define	OPND(n)	((n)&OPDMASK)
 #define	SOP(op, opnd)	((op)|(opnd))
 /* operators			   meaning	operand			*/
 /*						(back, fwd are offsets)	*/
-#define	OEND	(1UL<<OPSHIFT)	/* endmarker	-			*/
+#define	OEND	(1)		/* endmarker	-			*/
-#define	OCHAR	(2UL<<OPSHIFT)	/* character	unsigned char		*/
+#define	OCHAR	(2)		/* character	unsigned char		*/
-#define	OBOL	(3UL<<OPSHIFT)	/* left anchor	-			*/
+#define	OBOL	(3)		/* left anchor	-			*/
-#define	OEOL	(4UL<<OPSHIFT)	/* right anchor	-			*/
+#define	OEOL	(4)		/* right anchor	-			*/
-#define	OANY	(5UL<<OPSHIFT)	/* .		-			*/
+#define	OANY	(5)		/* .		-			*/
-#define	OANYOF	(6UL<<OPSHIFT)	/* [...]	set number		*/
+#define	OANYOF	(6)		/* [...]	set number		*/
-#define	OBACK_	(7UL<<OPSHIFT)	/* begin \d	paren number		*/
+#define	OBACK_	(7)		/* begin \d	paren number		*/
-#define	O_BACK	(8UL<<OPSHIFT)	/* end \d	paren number		*/
+#define	O_BACK	(8)		/* end \d	paren number		*/
-#define	OPLUS_	(9UL<<OPSHIFT)	/* + prefix	fwd to suffix		*/
+#define	OPLUS_	(9)		/* + prefix	fwd to suffix		*/
-#define	O_PLUS	(10UL<<OPSHIFT)	/* + suffix	back to prefix		*/
+#define	O_PLUS	(10)		/* + suffix	back to prefix		*/
-#define	OQUEST_	(11UL<<OPSHIFT)	/* ? prefix	fwd to suffix		*/
+#define	OQUEST_	(11)		/* ? prefix	fwd to suffix		*/
-#define	O_QUEST	(12UL<<OPSHIFT)	/* ? suffix	back to prefix		*/
+#define	O_QUEST	(12)		/* ? suffix	back to prefix		*/
-#define	OLPAREN	(13UL<<OPSHIFT)	/* (		fwd to )		*/
+#define	OLPAREN	(13)		/* (		fwd to )		*/
-#define	ORPAREN	(14UL<<OPSHIFT)	/* )		back to (		*/
+#define	ORPAREN	(14)		/* )		back to (		*/
-#define	OCH_	(15UL<<OPSHIFT)	/* begin choice	fwd to OOR2		*/
+#define	OCH_	(15)		/* begin choice	fwd to OOR2		*/
-#define	OOR1	(16UL<<OPSHIFT)	/* | pt. 1	back to OOR1 or OCH_	*/
+#define	OOR1	(16)		/* | pt. 1	back to OOR1 or OCH_	*/
-#define	OOR2	(17UL<<OPSHIFT)	/* | pt. 2	fwd to OOR2 or O_CH	*/
+#define	OOR2	(17)		/* | pt. 2	fwd to OOR2 or O_CH	*/
-#define	O_CH	(18UL<<OPSHIFT)	/* end choice	back to OOR1		*/
+#define	O_CH	(18)		/* end choice	back to OOR1		*/
-#define	OBOW	(19UL<<OPSHIFT)	/* begin word	-			*/
+#define	OBOW	(19)		/* begin word	-			*/
-#define	OEOW	(20UL<<OPSHIFT)	/* end word	-			*/
+#define	OEOW	(20)		/* end word	-			*/
 /*
  * Structure for [] character-set representation.  Character sets are
  * done as bit vectors, grouped 8 to a byte vector for compactness.
  * The individual set therefore has both a pointer to the byte vector
  * and a mask to pick out the relevant bit of each byte.  A hash code
  * simplifies testing whether two sets could be identical.
+ *
  * This will get trickier for multicharacter collating elements.  As
  * preliminary hooks for dealing with such things, we also carry along
  * a string of multi-character elements, and decide the size of the
  * vectors at run time.
  */
 @@ -135,26 +129,27 @@ typedef struct {
 #define	MCsub(p, cs, cp)	mcsub(p, cs, cp)
 #define	MCin(p, cs, cp)	mcin(p, cs, cp)
 /* stuff for character categories */
 typedef RCHAR_T cat_t;
 /*
  * main compiled-expression structure
  */
 struct re_guts {
 	int magic;
 #		define	MAGIC2	((('R'^0200)<<8)|'E')
 	sop *strip;		/* malloced area for strip */
 	RCHAR_T *stripdata;	/* malloced area for stripdata */
 	int csetsize;		/* number of bits in a cset vector */
 	int ncsets;		/* number of csets in use */
 	cset *sets;		/* -> cset [ncsets] */
 	uch *setbits;		/* -> uch[csetsize][ncsets/CHAR_BIT] */
 	int cflags;		/* copy of regcomp() cflags argument */
 	sopno nstates;		/* = number of sops */
 	sopno firststate;	/* the initial OEND (normally 0) */
 	sopno laststate;	/* the final OEND */
 	int iflags;		/* internal flags */
 #		define	USEBOL	01	/* used ^ */
 #		define	USEEOL	02	/* used $ */
 #		define	BAD	04	/* something wrong */
 	int nbol;		/* number of ^ used */
 @@ -165,15 +160,15 @@ struct re_guts {
 #endif
 	RCHAR_T *must;		/* match must contain this string */
 	int mlen;		/* length of must */
 	size_t nsub;		/* copy of re_nsub */
 	int backrefs;		/* does it use back references? */
 	sopno nplus;		/* how deep does it nest +s? */
 	/* catspace must be last */
 #if 0
 	cat_t catspace[1];	/* actually [NC] */
 #endif
 };
 /* misc utilities */
-#define	OUT	(RCHAR_T_MAX+1)	/* a non-character value */
+#define OUT	WEOF	/* a non-character value */
-#define	ISWORD(c)	((c <= 0xFF && isalnum(c)) || (c) == '_')
+#define	ISWORD(c)	(((UCHAR_T)c <= 0xFF && isalnum((unsigned char)c)) || (c) == '_')

 @@ -1,14 +1,14 @@
-/*	$NetBSD: key.c,v 1.3 2008/12/05 22:51:42 christos Exp $ */
+/*	$NetBSD: key.c,v 1.4 2009/01/02 00:32:11 tnozaki Exp $ */
 /*-
  * Copyright (c) 1991, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
  * Copyright (c) 1991, 1993, 1994, 1995, 1996
  *	Keith Bostic.  All rights reserved.
+ *
  * See the LICENSE file for redistribution information.
  */
 #include "config.h"
 #ifndef lint
 @@ -618,27 +618,28 @@ newmap:	evp = &wp->i_event[wp->i_next];
 	/*
 	 * If the key isn't mappable because:
+	 *
 	 *	+ ... the timeout has expired
 	 *	+ ... it's not a mappable key
 	 *	+ ... neither the command or input map flags are set
 	 *	+ ... there are no maps that can apply to it
+	 *
 	 * return it forthwith.
 	 */
 	if (istimeout || FL_ISSET(evp->e_flags, CH_NOMAP) ||
 	    !LF_ISSET(EC_MAPCOMMAND | EC_MAPINPUT) ||
-	    (evp->e_c < MAX_BIT_SEQ && !bit_test(gp->seqb, evp->e_c)))
+	    ((UCHAR_T)evp->e_c < MAX_BIT_SEQ &&
 	    !bit_test(gp->seqb, (UCHAR_T)evp->e_c)))
 		goto nomap;
 	/* Search the map. */
 	qp = seq_find(sp, NULL, evp, NULL, wp->i_cnt,
 	    LF_ISSET(EC_MAPCOMMAND) ? SEQ_COMMAND : SEQ_INPUT, &ispartial);
 	/*
 	 * If get a partial match, get more characters and retry the map.
 	 * If time out without further characters, return the characters
 	 * unmapped.
+	 *
 	 * !!!
 	 * <escape> characters are a problem.  Cursor keys start with <escape>

 @@ -1,47 +1,50 @@
-/*	$NetBSD: multibyte.h,v 1.1.1.2 2008/05/18 14:29:48 aymeric Exp $ */
+/*	$NetBSD: multibyte.h,v 1.2 2009/01/02 00:32:11 tnozaki Exp $ */
 #ifndef MULTIBYTE_H
 #define MULTIBYTE_H
 #ifdef USE_WIDECHAR
 #include <wchar.h>
 #include <wctype.h>
-typedef	wchar_t		RCHAR_T;
+typedef wchar_t		RCHAR_T;
-#define RCHAR_T_MAX	((1 << 24)-1)
+typedef wchar_t		CHAR_T;
-typedef	wchar_t		CHAR_T;
+#if defined(__NetBSD__)
-#define	MAX_CHAR_T	0xffffff    /* XXXX */
+#define RCHAR_T_MAX	0xffffffff
-typedef	u_int		UCHAR_T;
+#define MAX_CHAR_T	0xffffffff
-#define RCHAR_BIT	24
+#else
 #define RCHAR_T_MAX	WCHAR_MAX
 #define MAX_CHAR_T	WCHAR_MAX
 #endif
 typedef u_int		UCHAR_T;
 #define STRLEN		wcslen
 #define STRTOL		wcstol
 #define STRTOUL		wcstoul
 #define SPRINTF		swprintf
 #define STRCMP		wcscmp
 #define STRPBRK		wcspbrk
 #define TOUPPER		towupper
 #define STRSET		wmemset
 #define L(ch)		L ## ch
 #else
 typedef	char		RCHAR_T;
 #define RCHAR_T_MAX	CHAR_MAX
 typedef	u_char		CHAR_T;
 #define	MAX_CHAR_T	0xff
 typedef	u_char		UCHAR_T;
 #define RCHAR_BIT	CHAR_BIT
 #define STRLEN		strlen
 #define STRTOL		strtol
 #define STRTOUL		strtoul
 #define SPRINTF		snprintf
 #define STRCMP		strcmp
 #define STRPBRK		strpbrk
 #define TOUPPER		toupper
 #define STRSET		memset
 #define L(ch)		ch
 #endif

 @@ -1,14 +1,14 @@
-/*	$NetBSD: regfree.c,v 1.1.1.2 2008/05/18 14:31:39 aymeric Exp $ */
+/*	$NetBSD: regfree.c,v 1.2 2009/01/02 00:32:11 tnozaki Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994 Henry Spencer.
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Henry Spencer of the University of Toronto.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -61,21 +61,23 @@ regfree(regex_t *preg)
 	register struct re_guts *g;
 	if (preg->re_magic != MAGIC1)	/* oops */
 		return;			/* nice to complain, but hard */
 	g = preg->re_g;
 	if (g == NULL || g->magic != MAGIC2)	/* oops again */
 		return;
 	preg->re_magic = 0;		/* mark it invalid */
 	g->magic = 0;			/* mark it invalid */
 	if (g->strip != NULL)
 		free((char *)g->strip);
 	if (g->stripdata != NULL)
 		free((char *)g->stripdata);
 	if (g->sets != NULL)
 		free((char *)g->sets);
 	if (g->setbits != NULL)
 		free((char *)g->setbits);
 	if (g->must != NULL)
 		free(g->must);
 	free((char *)g);
+}