Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
  2. #include <stdio.h>
  3. #include <string.h>
  4. #include <ctype.h>
  5. #include <limits.h>
  6. #include <stdlib.h>
  7. #include <sys/types.h>
  8. #include <regex.h>
  9.  
  10. #include "utils.h"
  11. #include "regex2.h"
  12. #include "debug.ih"
  13.  
  14. /*
  15.  - regprint - print a regexp for debugging
  16.  == void regprint(regex_t *r, FILE *d);
  17.  */
  18. void
  19. regprint(r, d)
  20. regex_t *r;
  21. FILE *d;
  22. {
  23.         register struct re_guts *g = r->re_g;
  24.         register int i;
  25.         register int c;
  26.         register int last;
  27.         int nincat[NC];
  28.  
  29.         fprintf(d, "%ld states, %d categories", (long)g->nstates,
  30.                                                         g->ncategories);
  31.         fprintf(d, ", first %ld last %ld", (long)g->firststate,
  32.                                                 (long)g->laststate);
  33.         if (g->iflags&USEBOL)
  34.                 fprintf(d, ", USEBOL");
  35.         if (g->iflags&USEEOL)
  36.                 fprintf(d, ", USEEOL");
  37.         if (g->iflags&BAD)
  38.                 fprintf(d, ", BAD");
  39.         if (g->nsub > 0)
  40.                 fprintf(d, ", nsub=%ld", (long)g->nsub);
  41.         if (g->must != NULL)
  42.                 fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
  43.                                                                 g->must);
  44.         if (g->backrefs)
  45.                 fprintf(d, ", backrefs");
  46.         if (g->nplus > 0)
  47.                 fprintf(d, ", nplus %ld", (long)g->nplus);
  48.         fprintf(d, "\n");
  49.         s_print(g, d);
  50.         for (i = 0; i < g->ncategories; i++) {
  51.                 nincat[i] = 0;
  52.                 for (c = CHAR_MIN; c <= CHAR_MAX; c++)
  53.                         if (g->categories[c] == i)
  54.                                 nincat[i]++;
  55.         }
  56.         fprintf(d, "cc0#%d", nincat[0]);
  57.         for (i = 1; i < g->ncategories; i++)
  58.                 if (nincat[i] == 1) {
  59.                         for (c = CHAR_MIN; c <= CHAR_MAX; c++)
  60.                                 if (g->categories[c] == i)
  61.                                         break;
  62.                         fprintf(d, ", %d=%s", i, regchar(c));
  63.                 }
  64.         fprintf(d, "\n");
  65.         for (i = 1; i < g->ncategories; i++)
  66.                 if (nincat[i] != 1) {
  67.                         fprintf(d, "cc%d\t", i);
  68.                         last = -1;
  69.                         for (c = CHAR_MIN; c <= CHAR_MAX+1; c++)        /* +1 does flush */
  70.                                 if (c <= CHAR_MAX && g->categories[c] == i) {
  71.                                         if (last < 0) {
  72.                                                 fprintf(d, "%s", regchar(c));
  73.                                                 last = c;
  74.                                         }
  75.                                 } else {
  76.                                         if (last >= 0) {
  77.                                                 if (last != c-1)
  78.                                                         fprintf(d, "-%s",
  79.                                                                 regchar(c-1));
  80.                                                 last = -1;
  81.                                         }
  82.                                 }
  83.                         fprintf(d, "\n");
  84.                 }
  85. }
  86.  
  87. /*
  88.  - s_print - print the strip for debugging
  89.  == static void s_print(register struct re_guts *g, FILE *d);
  90.  */
  91. static void
  92. s_print(g, d)
  93. register struct re_guts *g;
  94. FILE *d;
  95. {
  96.         register sop *s;
  97.         register cset *cs;
  98.         register int i;
  99.         register int done = 0;
  100.         register sop opnd;
  101.         register int col = 0;
  102.         register int last;
  103.         register sopno offset = 2;
  104. #       define  GAP()   {       if (offset % 5 == 0) { \
  105.                                         if (col > 40) { \
  106.                                                 fprintf(d, "\n\t"); \
  107.                                                 col = 0; \
  108.                                         } else { \
  109.                                                 fprintf(d, " "); \
  110.                                                 col++; \
  111.                                         } \
  112.                                 } else \
  113.                                         col++; \
  114.                                 offset++; \
  115.                         }
  116.  
  117.         if (OP(g->strip[0]) != OEND)
  118.                 fprintf(d, "missing initial OEND!\n");
  119.         for (s = &g->strip[1]; !done; s++) {
  120.                 opnd = OPND(*s);
  121.                 switch (OP(*s)) {
  122.                 case OEND:
  123.                         fprintf(d, "\n");
  124.                         done = 1;
  125.                         break;
  126.                 case OCHAR:
  127.                         if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
  128.                                 fprintf(d, "\\%c", (char)opnd);
  129.                         else
  130.                                 fprintf(d, "%s", regchar((char)opnd));
  131.                         break;
  132.                 case OBOL:
  133.                         fprintf(d, "^");
  134.                         break;
  135.                 case OEOL:
  136.                         fprintf(d, "$");
  137.                         break;
  138.                 case OBOW:
  139.                         fprintf(d, "\\{");
  140.                         break;
  141.                 case OEOW:
  142.                         fprintf(d, "\\}");
  143.                         break;
  144.                 case OANY:
  145.                         fprintf(d, ".");
  146.                         break;
  147.                 case OANYOF:
  148.                         fprintf(d, "[(%ld)", (long)opnd);
  149.                         cs = &g->sets[opnd];
  150.                         last = -1;
  151.                         for (i = 0; i < g->csetsize+1; i++)     /* +1 flushes */
  152.                                 if (CHIN(cs, i) && i < g->csetsize) {
  153.                                         if (last < 0) {
  154.                                                 fprintf(d, "%s", regchar(i));
  155.                                                 last = i;
  156.                                         }
  157.                                 } else {
  158.                                         if (last >= 0) {
  159.                                                 if (last != i-1)
  160.                                                         fprintf(d, "-%s",
  161.                                                                 regchar(i-1));
  162.                                                 last = -1;
  163.                                         }
  164.                                 }
  165.                         fprintf(d, "]");
  166.                         break;
  167.                 case OBACK_:
  168.                         fprintf(d, "(\\<%ld>", (long)opnd);
  169.                         break;
  170.                 case O_BACK:
  171.                         fprintf(d, "<%ld>\\)", (long)opnd);
  172.                         break;
  173.                 case OPLUS_:
  174.                         fprintf(d, "(+");
  175.                         if (OP(*(s+opnd)) != O_PLUS)
  176.                                 fprintf(d, "<%ld>", (long)opnd);
  177.                         break;
  178.                 case O_PLUS:
  179.                         if (OP(*(s-opnd)) != OPLUS_)
  180.                                 fprintf(d, "<%ld>", (long)opnd);
  181.                         fprintf(d, "+)");
  182.                         break;
  183.                 case OQUEST_:
  184.                         fprintf(d, "(?");
  185.                         if (OP(*(s+opnd)) != O_QUEST)
  186.                                 fprintf(d, "<%ld>", (long)opnd);
  187.                         break;
  188.                 case O_QUEST:
  189.                         if (OP(*(s-opnd)) != OQUEST_)
  190.                                 fprintf(d, "<%ld>", (long)opnd);
  191.                         fprintf(d, "?)");
  192.                         break;
  193.                 case OLPAREN:
  194.                         fprintf(d, "((<%ld>", (long)opnd);
  195.                         break;
  196.                 case ORPAREN:
  197.                         fprintf(d, "<%ld>))", (long)opnd);
  198.                         break;
  199.                 case OCH_:
  200.                         fprintf(d, "<");
  201.                         if (OP(*(s+opnd)) != OOR2)
  202.                                 fprintf(d, "<%ld>", (long)opnd);
  203.                         break;
  204.                 case OOR1:
  205.                         if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
  206.                                 fprintf(d, "<%ld>", (long)opnd);
  207.                         fprintf(d, "|");
  208.                         break;
  209.                 case OOR2:
  210.                         fprintf(d, "|");
  211.                         if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
  212.                                 fprintf(d, "<%ld>", (long)opnd);
  213.                         break;
  214.                 case O_CH:
  215.                         if (OP(*(s-opnd)) != OOR1)
  216.                                 fprintf(d, "<%ld>", (long)opnd);
  217.                         fprintf(d, ">");
  218.                         break;
  219.                 default:
  220.                         fprintf(d, "!%d(%d)!", OP(*s), opnd);
  221.                         break;
  222.                 }
  223.                 if (!done)
  224.                         GAP();
  225.         }
  226. }
  227.  
  228. /*
  229.  - regchar - make a character printable
  230.  == static char *regchar(int ch);
  231.  */
  232. static char *                   /* -> representation */
  233. regchar(ch)
  234. int ch;
  235. {
  236.         static char buf[10];
  237.  
  238.         if (isprint(ch) || ch == ' ')
  239.                 sprintf(buf, "%c", ch);
  240.         else
  241.                 sprintf(buf, "\\%o", ch);
  242.         return(buf);
  243. }
  244.