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