home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 January / Chip_2001-01_cd1.bin / tema / mysql / mysql-3.23.28g-win-source.exe / regex / debug.c < prev    next >
C/C++ Source or Header  |  2000-10-03  |  5KB  |  244 lines
  1. #include <global.h>
  2. #include <m_ctype.h>
  3. #include <m_string.h>
  4. #include <sys/types.h>
  5. #include <regex.h>
  6. #include "utils.h"
  7. #include "regex2.h"
  8. #include "debug.ih"
  9.  
  10. /* Added extra paramter to regchar to remove static buffer ; Monty 96.11.27 */
  11.  
  12. /*
  13.  - regprint - print a regexp for debugging
  14.  == void regprint(regex_t *r, FILE *d);
  15.  */
  16. void
  17. regprint(r, d)
  18. regex_t *r;
  19. FILE *d;
  20. {
  21.     register struct re_guts *g = r->re_g;
  22.     register int i;
  23.     register int c;
  24.     register int last;
  25.     int nincat[NC];
  26.     char buf[10];
  27.  
  28.     fprintf(d, "%ld states, %d categories", (long)g->nstates,
  29.                             g->ncategories);
  30.     fprintf(d, ", first %ld last %ld", (long)g->firststate,
  31.                         (long)g->laststate);
  32.     if (g->iflags&USEBOL)
  33.         fprintf(d, ", USEBOL");
  34.     if (g->iflags&USEEOL)
  35.         fprintf(d, ", USEEOL");
  36.     if (g->iflags&BAD)
  37.         fprintf(d, ", BAD");
  38.     if (g->nsub > 0)
  39.         fprintf(d, ", nsub=%ld", (long)g->nsub);
  40.     if (g->must != NULL)
  41.         fprintf(d, ", must(%ld) `%*s'", (long)g->mlen, (int)g->mlen,
  42.                                 g->must);
  43.     if (g->backrefs)
  44.         fprintf(d, ", backrefs");
  45.     if (g->nplus > 0)
  46.         fprintf(d, ", nplus %ld", (long)g->nplus);
  47.     fprintf(d, "\n");
  48.     s_print(g, d);
  49.     for (i = 0; i < g->ncategories; i++) {
  50.         nincat[i] = 0;
  51.         for (c = CHAR_MIN; c <= CHAR_MAX; c++)
  52.             if (g->categories[c] == i)
  53.                 nincat[i]++;
  54.     }
  55.     fprintf(d, "cc0#%d", nincat[0]);
  56.     for (i = 1; i < g->ncategories; i++)
  57.         if (nincat[i] == 1) {
  58.             for (c = CHAR_MIN; c <= CHAR_MAX; c++)
  59.                 if (g->categories[c] == i)
  60.                     break;
  61.             fprintf(d, ", %d=%s", i, regchar(c,buf));
  62.         }
  63.     fprintf(d, "\n");
  64.     for (i = 1; i < g->ncategories; i++)
  65.         if (nincat[i] != 1) {
  66.             fprintf(d, "cc%d\t", i);
  67.             last = -1;
  68.             for (c = CHAR_MIN; c <= CHAR_MAX+1; c++)    /* +1 does flush */
  69.                 if (c <= CHAR_MAX && g->categories[c] == i) {
  70.                     if (last < 0) {
  71.                         fprintf(d, "%s", regchar(c,buf));
  72.                         last = c;
  73.                     }
  74.                 } else {
  75.                     if (last >= 0) {
  76.                         if (last != c-1)
  77.                             fprintf(d, "-%s",
  78.                                 regchar(c-1,buf));
  79.                         last = -1;
  80.                     }
  81.                 }
  82.             fprintf(d, "\n");
  83.         }
  84. }
  85.  
  86. /*
  87.  - s_print - print the strip for debugging
  88.  == static void s_print(register struct re_guts *g, FILE *d);
  89.  */
  90. static void
  91. s_print(g, d)
  92. register struct re_guts *g;
  93. FILE *d;
  94. {
  95.     register sop *s;
  96.     register cset *cs;
  97.     register int i;
  98.     register int done = 0;
  99.     register sop opnd;
  100.     register int col = 0;
  101.     register int last;
  102.     register sopno offset = 2;
  103.     char buf[10];
  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,buf));
  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,buf));
  155.                         last = i;
  156.                     }
  157.                 } else {
  158.                     if (last >= 0) {
  159.                         if (last != i-1)
  160.                             fprintf(d, "-%s",
  161.                                 regchar(i-1,buf));
  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, "!%ld(%ld)!", 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,buf)
  234. int ch;
  235. char *buf;
  236. {
  237.  
  238.     if (isprint(ch) || ch == ' ')
  239.         sprintf(buf, "%c", ch);
  240.     else
  241.         sprintf(buf, "\\%o", ch);
  242.     return(buf);
  243. }
  244.