===================================================================
RCS file: /cvsrepo/anoncvs/cvs/src/usr.bin/less/Attic/regexp.c,v
retrieving revision 1.2
retrieving revision 1.3
diff -u -r1.2 -r1.3
--- src/usr.bin/less/Attic/regexp.c	2001/01/29 01:58:04	1.2
+++ src/usr.bin/less/Attic/regexp.c	2001/11/19 19:02:14	1.3
@@ -1,4 +1,4 @@
-/*	$OpenBSD: regexp.c,v 1.2 2001/01/29 01:58:04 niklas Exp $	*/
+/*	$OpenBSD: regexp.c,v 1.3 2001/11/19 19:02:14 mpech Exp $	*/
 
 /*
  * regcomp and regexec -- regsub and regerror are elsewhere
@@ -202,10 +202,10 @@
 regcomp(exp)
 char *exp;
 {
-	register regexp *r;
-	register char *scan;
-	register char *longest;
-	register int len;
+	regexp *r;
+	char *scan;
+	char *longest;
+	int len;
 	int flags;
 
 	if (exp == NULL)
@@ -290,10 +290,10 @@
 int paren;			/* Parenthesized? */
 int *flagp;
 {
-	register char *ret;
-	register char *br;
-	register char *ender;
-	register int parno = 0;
+	char *ret;
+	char *br;
+	char *ender;
+	int parno = 0;
 	int flags;
 
 	*flagp = HASWIDTH;	/* Tentatively. */
@@ -361,9 +361,9 @@
 regbranch(flagp)
 int *flagp;
 {
-	register char *ret;
-	register char *chain;
-	register char *latest;
+	char *ret;
+	char *chain;
+	char *latest;
 	int flags;
 
 	*flagp = WORST;		/* Tentatively. */
@@ -400,9 +400,9 @@
 regpiece(flagp)
 int *flagp;
 {
-	register char *ret;
-	register char op;
-	register char *next;
+	char *ret;
+	char op;
+	char *next;
 	int flags;
 
 	ret = regatom(&flags);
@@ -464,7 +464,7 @@
 regatom(flagp)
 int *flagp;
 {
-	register char *ret;
+	char *ret;
 	int flags;
 
 	*flagp = WORST;		/* Tentatively. */
@@ -481,8 +481,8 @@
 		*flagp |= HASWIDTH|SIMPLE;
 		break;
 	case '[': {
-			register int clss;
-			register int classend;
+			int clss;
+			int classend;
 
 			if (*regparse == '^') {	/* Complement of range. */
 				ret = regnode(ANYBUT);
@@ -542,8 +542,8 @@
 		*flagp |= HASWIDTH|SIMPLE;
 		break;
 	default: {
-			register int len;
-			register char ender;
+			int len;
+			char ender;
 
 			regparse--;
 			len = strcspn(regparse, META);
@@ -575,8 +575,8 @@
 regnode(op)
 char op;
 {
-	register char *ret;
-	register char *ptr;
+	char *ret;
+	char *ptr;
 
 	ret = regcode;
 	if (ret == &regdummy) {
@@ -616,9 +616,9 @@
 char op;
 char *opnd;
 {
-	register char *src;
-	register char *dst;
-	register char *place;
+	char *src;
+	char *dst;
+	char *place;
 
 	if (regcode == &regdummy) {
 		regsize += 3;
@@ -645,9 +645,9 @@
 char *p;
 char *val;
 {
-	register char *scan;
-	register char *temp;
-	register int offset;
+	char *scan;
+	char *temp;
+	int offset;
 
 	if (p == &regdummy)
 		return;
@@ -713,10 +713,10 @@
  */
 int
 regexec(prog, string)
-register regexp *prog;
-register char *string;
+regexp *prog;
+char *string;
 {
-	register char *s;
+	char *s;
 
 	/* Be paranoid... */
 	if (prog == NULL || string == NULL) {
@@ -777,9 +777,9 @@
 regexp *prog;
 char *string;
 {
-	register int i;
-	register char **sp;
-	register char **ep;
+	int i;
+	char **sp;
+	char **ep;
 
 	reginput = string;
 	regstartp = prog->startp;
@@ -813,7 +813,7 @@
 regmatch(prog)
 char *prog;
 {
-	register char *scan;	/* Current node. */
+	char *scan;	/* Current node. */
 	char *next;		/* Next node. */
 
 	scan = prog;
@@ -843,8 +843,8 @@
 			reginput++;
 			break;
 		case EXACTLY: {
-				register int len;
-				register char *opnd;
+				int len;
+				char *opnd;
 
 				opnd = OPERAND(scan);
 				/* Inline the first character, for speed. */
@@ -879,8 +879,8 @@
 		case OPEN+7:
 		case OPEN+8:
 		case OPEN+9: {
-				register int no;
-				register char *save;
+				int no;
+				char *save;
 
 				no = OP(scan) - OPEN;
 				save = reginput;
@@ -908,8 +908,8 @@
 		case CLOSE+7:
 		case CLOSE+8:
 		case CLOSE+9: {
-				register int no;
-				register char *save;
+				int no;
+				char *save;
 
 				no = OP(scan) - CLOSE;
 				save = reginput;
@@ -929,7 +929,7 @@
 			/* NOTREACHED */
 			break;
 		case BRANCH: {
-				register char *save;
+				char *save;
 
 				if (OP(next) != BRANCH)		/* No choice. */
 					next = OPERAND(scan);	/* Avoid recursion. */
@@ -949,10 +949,10 @@
 			break;
 		case STAR:
 		case PLUS: {
-				register char nextch;
-				register int no;
-				register char *save;
-				register int min;
+				char nextch;
+				int no;
+				char *save;
+				int min;
 
 				/*
 				 * Lookahead to avoid useless match attempts
@@ -1006,9 +1006,9 @@
 regrepeat(p)
 char *p;
 {
-	register int count = 0;
-	register char *scan;
-	register char *opnd;
+	int count = 0;
+	char *scan;
+	char *opnd;
 
 	scan = reginput;
 	opnd = OPERAND(p);
@@ -1050,9 +1050,9 @@
  */
 static char *
 regnext(p)
-register char *p;
+char *p;
 {
-	register int offset;
+	int offset;
 
 	if (p == &regdummy)
 		return(NULL);
@@ -1078,9 +1078,9 @@
 regdump(r)
 regexp *r;
 {
-	register char *s;
-	register char op = EXACTLY;	/* Arbitrary non-END op. */
-	register char *next;
+	char *s;
+	char op = EXACTLY;	/* Arbitrary non-END op. */
+	char *next;
 
 
 	s = r->program + 1;
@@ -1121,7 +1121,7 @@
 regprop(op)
 char *op;
 {
-	register char *p;
+	char *p;
 	static char buf[50];
 
 	(void) strcpy(buf, ":");
@@ -1214,9 +1214,9 @@
 char *s1;
 char *s2;
 {
-	register char *scan1;
-	register char *scan2;
-	register int count;
+	char *scan1;
+	char *scan2;
+	int count;
 
 	count = 0;
 	for (scan1 = s1; *scan1 != '\0'; scan1++) {