[Emacs-diffs] Changes to emacs/src/regex.c

[Dave Love]

Index: emacs/src/regex.c
diff -c emacs/src/regex.c:1.185 emacs/src/regex.c:1.186
*** emacs/src/regex.c:1.185     Tue Feb  4 09:03:13 2003
--- emacs/src/regex.c   Sun Feb 23 10:00:30 2003
***************
*** 921,970 ****
  
    if (start == NULL)
      {
!       printf ("(null)\n");
        return;
      }
  
    /* Loop over pattern commands.  */
    while (p < pend)
      {
!       printf ("%d:\t", p - start);
  
        switch ((re_opcode_t) *p++)
        {
        case no_op:
!         printf ("/no_op");
          break;
  
        case succeed:
!         printf ("/succeed");
          break;
  
        case exactn:
          mcnt = *p++;
!         printf ("/exactn/%d", mcnt);
          do
            {
!             putchar ('/');
!             putchar (*p++);
            }
          while (--mcnt);
          break;
  
        case start_memory:
!         printf ("/start_memory/%d", *p++);
          break;
  
        case stop_memory:
!         printf ("/stop_memory/%d", *p++);
          break;
  
        case duplicate:
!         printf ("/duplicate/%d", *p++);
          break;
  
        case anychar:
!         printf ("/anychar");
          break;
  
        case charset:
--- 921,969 ----
  
    if (start == NULL)
      {
!       fprintf (stderr, "(null)\n");
        return;
      }
  
    /* Loop over pattern commands.  */
    while (p < pend)
      {
!       fprintf (stderr, "%d:\t", p - start);
  
        switch ((re_opcode_t) *p++)
        {
        case no_op:
!         fprintf (stderr, "/no_op");
          break;
  
        case succeed:
!         fprintf (stderr, "/succeed");
          break;
  
        case exactn:
          mcnt = *p++;
!         fprintf (stderr, "/exactn/%d", mcnt);
          do
            {
!             fprintf (stderr, "/%c", *p++);
            }
          while (--mcnt);
          break;
  
        case start_memory:
!         fprintf (stderr, "/start_memory/%d", *p++);
          break;
  
        case stop_memory:
!         fprintf (stderr, "/stop_memory/%d", *p++);
          break;
  
        case duplicate:
!         fprintf (stderr, "/duplicate/%d", *p++);
          break;
  
        case anychar:
!         fprintf (stderr, "/anychar");
          break;
  
        case charset:
***************
*** 975,981 ****
            int length = CHARSET_BITMAP_SIZE (p - 1);
            int has_range_table = CHARSET_RANGE_TABLE_EXISTS_P (p - 1);
  
!           printf ("/charset [%s",
                    (re_opcode_t) *(p - 1) == charset_not ? "^" : "");
  
            assert (p + *p < pend);
--- 974,980 ----
            int length = CHARSET_BITMAP_SIZE (p - 1);
            int has_range_table = CHARSET_RANGE_TABLE_EXISTS_P (p - 1);
  
!           fprintf (stderr, "/charset [%s",
                    (re_opcode_t) *(p - 1) == charset_not ? "^" : "");
  
            assert (p + *p < pend);
***************
*** 987,1019 ****
                  /* Are we starting a range?  */
                  if (last + 1 == c && ! in_range)
                    {
!                     putchar ('-');
                      in_range = 1;
                    }
                  /* Have we broken a range?  */
                  else if (last + 1 != c && in_range)
                    {
!                     putchar (last);
                      in_range = 0;
                    }
  
                  if (! in_range)
!                   putchar (c);
  
                  last = c;
              }
  
            if (in_range)
!             putchar (last);
  
!           putchar (']');
  
            p += 1 + length;
  
            if (has_range_table)
              {
                int count;
!               printf ("has-range-table");
  
                /* ??? Should print the range table; for now, just skip it.  */
                p += 2;         /* skip range table bits */
--- 986,1018 ----
                  /* Are we starting a range?  */
                  if (last + 1 == c && ! in_range)
                    {
!                     fprintf (stderr, "-");
                      in_range = 1;
                    }
                  /* Have we broken a range?  */
                  else if (last + 1 != c && in_range)
                    {
!                     fprintf (stderr, "%c", last);
                      in_range = 0;
                    }
  
                  if (! in_range)
!                   fprintf (stderr, "%c", c);
  
                  last = c;
              }
  
            if (in_range)
!             fprintf (stderr, "%c", last);
  
!           fprintf (stderr, "]");
  
            p += 1 + length;
  
            if (has_range_table)
              {
                int count;
!               fprintf (stderr, "has-range-table");
  
                /* ??? Should print the range table; for now, just skip it.  */
                p += 2;         /* skip range table bits */
***************
*** 1024,1153 ****
          break;
  
        case begline:
!         printf ("/begline");
          break;
  
        case endline:
!         printf ("/endline");
          break;
  
        case on_failure_jump:
          extract_number_and_incr (&mcnt, &p);
!         printf ("/on_failure_jump to %d", p + mcnt - start);
          break;
  
        case on_failure_keep_string_jump:
          extract_number_and_incr (&mcnt, &p);
!         printf ("/on_failure_keep_string_jump to %d", p + mcnt - start);
          break;
  
        case on_failure_jump_nastyloop:
          extract_number_and_incr (&mcnt, &p);
!         printf ("/on_failure_jump_nastyloop to %d", p + mcnt - start);
          break;
  
        case on_failure_jump_loop:
          extract_number_and_incr (&mcnt, &p);
!         printf ("/on_failure_jump_loop to %d", p + mcnt - start);
          break;
  
        case on_failure_jump_smart:
          extract_number_and_incr (&mcnt, &p);
!         printf ("/on_failure_jump_smart to %d", p + mcnt - start);
          break;
  
        case jump:
          extract_number_and_incr (&mcnt, &p);
!         printf ("/jump to %d", p + mcnt - start);
          break;
  
        case succeed_n:
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
!         printf ("/succeed_n to %d, %d times", p - 2 + mcnt - start, mcnt2);
          break;
  
        case jump_n:
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
!         printf ("/jump_n to %d, %d times", p - 2 + mcnt - start, mcnt2);
          break;
  
        case set_number_at:
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
!         printf ("/set_number_at location %d to %d", p - 2 + mcnt - start, 
mcnt2);
          break;
  
        case wordbound:
!         printf ("/wordbound");
          break;
  
        case notwordbound:
!         printf ("/notwordbound");
          break;
  
        case wordbeg:
!         printf ("/wordbeg");
          break;
  
        case wordend:
!         printf ("/wordend");
  
        case syntaxspec:
!         printf ("/syntaxspec");
          mcnt = *p++;
!         printf ("/%d", mcnt);
          break;
  
        case notsyntaxspec:
!         printf ("/notsyntaxspec");
          mcnt = *p++;
!         printf ("/%d", mcnt);
          break;
  
  # ifdef emacs
        case before_dot:
!         printf ("/before_dot");
          break;
  
        case at_dot:
!         printf ("/at_dot");
          break;
  
        case after_dot:
!         printf ("/after_dot");
          break;
  
        case categoryspec:
!         printf ("/categoryspec");
          mcnt = *p++;
!         printf ("/%d", mcnt);
          break;
  
        case notcategoryspec:
!         printf ("/notcategoryspec");
          mcnt = *p++;
!         printf ("/%d", mcnt);
          break;
  # endif /* emacs */
  
        case begbuf:
!         printf ("/begbuf");
          break;
  
        case endbuf:
!         printf ("/endbuf");
          break;
  
        default:
!         printf ("?%d", *(p-1));
        }
  
!       putchar ('\n');
      }
  
!   printf ("%d:\tend of pattern.\n", p - start);
  }
  
  
--- 1023,1152 ----
          break;
  
        case begline:
!         fprintf (stderr, "/begline");
          break;
  
        case endline:
!         fprintf (stderr, "/endline");
          break;
  
        case on_failure_jump:
          extract_number_and_incr (&mcnt, &p);
!         fprintf (stderr, "/on_failure_jump to %d", p + mcnt - start);
          break;
  
        case on_failure_keep_string_jump:
          extract_number_and_incr (&mcnt, &p);
!         fprintf (stderr, "/on_failure_keep_string_jump to %d", p + mcnt - 
start);
          break;
  
        case on_failure_jump_nastyloop:
          extract_number_and_incr (&mcnt, &p);
!         fprintf (stderr, "/on_failure_jump_nastyloop to %d", p + mcnt - 
start);
          break;
  
        case on_failure_jump_loop:
          extract_number_and_incr (&mcnt, &p);
!         fprintf (stderr, "/on_failure_jump_loop to %d", p + mcnt - start);
          break;
  
        case on_failure_jump_smart:
          extract_number_and_incr (&mcnt, &p);
!         fprintf (stderr, "/on_failure_jump_smart to %d", p + mcnt - start);
          break;
  
        case jump:
          extract_number_and_incr (&mcnt, &p);
!         fprintf (stderr, "/jump to %d", p + mcnt - start);
          break;
  
        case succeed_n:
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
!         fprintf (stderr, "/succeed_n to %d, %d times", p - 2 + mcnt - start, 
mcnt2);
          break;
  
        case jump_n:
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
!         fprintf (stderr, "/jump_n to %d, %d times", p - 2 + mcnt - start, 
mcnt2);
          break;
  
        case set_number_at:
          extract_number_and_incr (&mcnt, &p);
          extract_number_and_incr (&mcnt2, &p);
!         fprintf (stderr, "/set_number_at location %d to %d", p - 2 + mcnt - 
start, mcnt2);
          break;
  
        case wordbound:
!         fprintf (stderr, "/wordbound");
          break;
  
        case notwordbound:
!         fprintf (stderr, "/notwordbound");
          break;
  
        case wordbeg:
!         fprintf (stderr, "/wordbeg");
          break;
  
        case wordend:
!         fprintf (stderr, "/wordend");
  
        case syntaxspec:
!         fprintf (stderr, "/syntaxspec");
          mcnt = *p++;
!         fprintf (stderr, "/%d", mcnt);
          break;
  
        case notsyntaxspec:
!         fprintf (stderr, "/notsyntaxspec");
          mcnt = *p++;
!         fprintf (stderr, "/%d", mcnt);
          break;
  
  # ifdef emacs
        case before_dot:
!         fprintf (stderr, "/before_dot");
          break;
  
        case at_dot:
!         fprintf (stderr, "/at_dot");
          break;
  
        case after_dot:
!         fprintf (stderr, "/after_dot");
          break;
  
        case categoryspec:
!         fprintf (stderr, "/categoryspec");
          mcnt = *p++;
!         fprintf (stderr, "/%d", mcnt);
          break;
  
        case notcategoryspec:
!         fprintf (stderr, "/notcategoryspec");
          mcnt = *p++;
!         fprintf (stderr, "/%d", mcnt);
          break;
  # endif /* emacs */
  
        case begbuf:
!         fprintf (stderr, "/begbuf");
          break;
  
        case endbuf:
!         fprintf (stderr, "/endbuf");
          break;
  
        default:
!         fprintf (stderr, "?%d", *(p-1));
        }
  
!       fprintf (stderr, "\n");
      }
  
!   fprintf (stderr, "%d:\tend of pattern.\n", p - start);
  }