Annotation of embedaddon/php/ext/ereg/regex/debug.c, revision 1.1

1.1     ! misho       1: #include <stdio.h>
        !             2: #include <string.h>
        !             3: #include <ctype.h>
        !             4: #include <limits.h>
        !             5: #include <stdlib.h>
        !             6: #include <sys/types.h>
        !             7: #include <regex.h>
        !             8: 
        !             9: #include "utils.h"
        !            10: #include "regex2.h"
        !            11: #include "debug.ih"
        !            12: 
        !            13: /*
        !            14:  - regprint - print a regexp for debugging
        !            15:  == void regprint(regex_t *r, FILE *d);
        !            16:  */
        !            17: void
        !            18: regprint(r, d)
        !            19: regex_t *r;
        !            20: FILE *d;
        !            21: {
        !            22:        register struct re_guts *g = r->re_g;
        !            23:        register int i;
        !            24:        register int c;
        !            25:        register int last;
        !            26:        int nincat[NC];
        !            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));
        !            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));
        !            72:                                                last = c;
        !            73:                                        }
        !            74:                                } else {
        !            75:                                        if (last >= 0) {
        !            76:                                                if (last != c-1)
        !            77:                                                        fprintf(d, "-%s",
        !            78:                                                                regchar(c-1));
        !            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: #      define  GAP()   {       if (offset % 5 == 0) { \
        !           104:                                        if (col > 40) { \
        !           105:                                                fprintf(d, "\n\t"); \
        !           106:                                                col = 0; \
        !           107:                                        } else { \
        !           108:                                                fprintf(d, " "); \
        !           109:                                                col++; \
        !           110:                                        } \
        !           111:                                } else \
        !           112:                                        col++; \
        !           113:                                offset++; \
        !           114:                        }
        !           115: 
        !           116:        if (OP(g->strip[0]) != OEND)
        !           117:                fprintf(d, "missing initial OEND!\n");
        !           118:        for (s = &g->strip[1]; !done; s++) {
        !           119:                opnd = OPND(*s);
        !           120:                switch (OP(*s)) {
        !           121:                case OEND:
        !           122:                        fprintf(d, "\n");
        !           123:                        done = 1;
        !           124:                        break;
        !           125:                case OCHAR:
        !           126:                        if (strchr("\\|()^$.[+*?{}!<> ", (char)opnd) != NULL)
        !           127:                                fprintf(d, "\\%c", (unsigned char)opnd);
        !           128:                        else
        !           129:                                fprintf(d, "%s", regchar((unsigned char)opnd));
        !           130:                        break;
        !           131:                case OBOL:
        !           132:                        fprintf(d, "^");
        !           133:                        break;
        !           134:                case OEOL:
        !           135:                        fprintf(d, "$");
        !           136:                        break;
        !           137:                case OBOW:
        !           138:                        fprintf(d, "\\{");
        !           139:                        break;
        !           140:                case OEOW:
        !           141:                        fprintf(d, "\\}");
        !           142:                        break;
        !           143:                case OANY:
        !           144:                        fprintf(d, ".");
        !           145:                        break;
        !           146:                case OANYOF:
        !           147:                        fprintf(d, "[(%ld)", (long)opnd);
        !           148:                        cs = &g->sets[opnd];
        !           149:                        last = -1;
        !           150:                        for (i = 0; i < g->csetsize+1; i++)     /* +1 flushes */
        !           151:                                if (CHIN(cs, i) && i < g->csetsize) {
        !           152:                                        if (last < 0) {
        !           153:                                                fprintf(d, "%s", regchar(i));
        !           154:                                                last = i;
        !           155:                                        }
        !           156:                                } else {
        !           157:                                        if (last >= 0) {
        !           158:                                                if (last != i-1)
        !           159:                                                        fprintf(d, "-%s",
        !           160:                                                                regchar(i-1));
        !           161:                                                last = -1;
        !           162:                                        }
        !           163:                                }
        !           164:                        fprintf(d, "]");
        !           165:                        break;
        !           166:                case OBACK_:
        !           167:                        fprintf(d, "(\\<%ld>", (long)opnd);
        !           168:                        break;
        !           169:                case O_BACK:
        !           170:                        fprintf(d, "<%ld>\\)", (long)opnd);
        !           171:                        break;
        !           172:                case OPLUS_:
        !           173:                        fprintf(d, "(+");
        !           174:                        if (OP(*(s+opnd)) != O_PLUS)
        !           175:                                fprintf(d, "<%ld>", (long)opnd);
        !           176:                        break;
        !           177:                case O_PLUS:
        !           178:                        if (OP(*(s-opnd)) != OPLUS_)
        !           179:                                fprintf(d, "<%ld>", (long)opnd);
        !           180:                        fprintf(d, "+)");
        !           181:                        break;
        !           182:                case OQUEST_:
        !           183:                        fprintf(d, "(?");
        !           184:                        if (OP(*(s+opnd)) != O_QUEST)
        !           185:                                fprintf(d, "<%ld>", (long)opnd);
        !           186:                        break;
        !           187:                case O_QUEST:
        !           188:                        if (OP(*(s-opnd)) != OQUEST_)
        !           189:                                fprintf(d, "<%ld>", (long)opnd);
        !           190:                        fprintf(d, "?)");
        !           191:                        break;
        !           192:                case OLPAREN:
        !           193:                        fprintf(d, "((<%ld>", (long)opnd);
        !           194:                        break;
        !           195:                case ORPAREN:
        !           196:                        fprintf(d, "<%ld>))", (long)opnd);
        !           197:                        break;
        !           198:                case OCH_:
        !           199:                        fprintf(d, "<");
        !           200:                        if (OP(*(s+opnd)) != OOR2)
        !           201:                                fprintf(d, "<%ld>", (long)opnd);
        !           202:                        break;
        !           203:                case OOR1:
        !           204:                        if (OP(*(s-opnd)) != OOR1 && OP(*(s-opnd)) != OCH_)
        !           205:                                fprintf(d, "<%ld>", (long)opnd);
        !           206:                        fprintf(d, "|");
        !           207:                        break;
        !           208:                case OOR2:
        !           209:                        fprintf(d, "|");
        !           210:                        if (OP(*(s+opnd)) != OOR2 && OP(*(s+opnd)) != O_CH)
        !           211:                                fprintf(d, "<%ld>", (long)opnd);
        !           212:                        break;
        !           213:                case O_CH:
        !           214:                        if (OP(*(s-opnd)) != OOR1)
        !           215:                                fprintf(d, "<%ld>", (long)opnd);
        !           216:                        fprintf(d, ">");
        !           217:                        break;
        !           218:                default:
        !           219:                        fprintf(d, "!%ld(%ld)!", OP(*s), opnd);
        !           220:                        break;
        !           221:                }
        !           222:                if (!done)
        !           223:                        GAP();
        !           224:        }
        !           225: }
        !           226: 
        !           227: /*
        !           228:  - regchar - make a character printable
        !           229:  == static char *regchar(int ch);
        !           230:  */
        !           231: static unsigned char *                 /* -> representation */
        !           232: regchar(ch)
        !           233: int ch;
        !           234: {
        !           235:        static unsigned char buf[10];
        !           236: 
        !           237:        if (isprint(ch) || ch == ' ')
        !           238:                sprintf(buf, "%c", ch);
        !           239:        else
        !           240:                sprintf(buf, "\\%o", ch);
        !           241:        return(buf);
        !           242: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>