[BACK]Return to regexp.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / less

Diff for /src/usr.bin/less/Attic/regexp.c between version 1.2 and 1.3

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