Changes to allow compiler with gcc-2.8.1 in C++ mode,

[p5sagit/p5-mst-13.2.git] / regcomp.c

diff --git a/regcomp.c b/regcomp.c
index 11358db..8d66f38 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -127,7 +127,6 @@ static regnode *reg_node _((U8));
 static regnode *regpiece _((I32 *));
 static void reginsert _((U8, regnode *));
 static void regoptail _((regnode *, regnode *));
-static void regset _((char *, I32));
 static void regtail _((regnode *, regnode *));
 static char* regwhite _((char *, char *));
 static char* nextchar _((void));
@@ -140,7 +139,6 @@ static I32 extralen;
 
 #ifdef DEBUGGING
 static int colorset;
-char *colors[4];
 #endif 
 
 /* Length of a variant. */
@@ -171,8 +169,13 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 #define SF_FIX_BEFORE_EOL      (SF_FIX_BEFORE_SEOL|SF_FIX_BEFORE_MEOL)
 #define SF_FL_BEFORE_EOL       (SF_FL_BEFORE_SEOL|SF_FL_BEFORE_MEOL)
 
-#define SF_FIX_SHIFT_EOL       (+2)
-#define SF_FL_SHIFT_EOL                (+4)
+#ifdef NO_UNARY_PLUS
+#  define SF_FIX_SHIFT_EOL     (0+2)
+#  define SF_FL_SHIFT_EOL              (0+4)
+#else
+#  define SF_FIX_SHIFT_EOL     (+2)
+#  define SF_FL_SHIFT_EOL              (+4)
+#endif
 
 #define SF_FIX_BEFORE_SEOL     (SF_BEFORE_SEOL << SF_FIX_SHIFT_EOL)
 #define SF_FIX_BEFORE_MEOL     (SF_BEFORE_MEOL << SF_FIX_SHIFT_EOL)
@@ -1827,15 +1830,6 @@ regwhite(char *p, char *e)
     return p;
 }
 
-static void
-regset(char *opnd, register I32 c)
-{
-    if (SIZE_ONLY)
-       return;
-    c &= 0xFF;
-    opnd[1 + (c >> 3)] |= (1 << (c & 7));
-}
-
 static regnode *
 regclass(void)
 {
@@ -1899,63 +1893,67 @@ regclass(void)
            Class = UCHARAT(regparse++);
            switch (Class) {
            case 'w':
-               if (regflags & PMf_LOCALE) {
-                   if (!SIZE_ONLY)
+               if (!SIZE_ONLY) {
+                   if (regflags & PMf_LOCALE)
                        *opnd |= ANYOF_ALNUML;
-               }
-               else {
-                   for (Class = 0; Class < 256; Class++)
-                       if (isALNUM(Class))
-                           regset(opnd, Class);
+                   else {
+                       for (Class = 0; Class < 256; Class++)
+                           if (isALNUM(Class))
+                               ANYOF_SET(opnd, Class);
+                   }
                }
                lastclass = 1234;
                continue;
            case 'W':
-               if (regflags & PMf_LOCALE) {
-                   if (!SIZE_ONLY)
+               if (!SIZE_ONLY) {
+                   if (regflags & PMf_LOCALE)
                        *opnd |= ANYOF_NALNUML;
-               }
-               else {
-                   for (Class = 0; Class < 256; Class++)
-                       if (!isALNUM(Class))
-                           regset(opnd, Class);
+                   else {
+                       for (Class = 0; Class < 256; Class++)
+                           if (!isALNUM(Class))
+                               ANYOF_SET(opnd, Class);
+                   }
                }
                lastclass = 1234;
                continue;
            case 's':
-               if (regflags & PMf_LOCALE) {
-                   if (!SIZE_ONLY)
+               if (!SIZE_ONLY) {
+                   if (regflags & PMf_LOCALE)
                        *opnd |= ANYOF_SPACEL;
-               }
-               else {
-                   for (Class = 0; Class < 256; Class++)
-                       if (isSPACE(Class))
-                           regset(opnd, Class);
+                   else {
+                       for (Class = 0; Class < 256; Class++)
+                           if (isSPACE(Class))
+                               ANYOF_SET(opnd, Class);
+                   }
                }
                lastclass = 1234;
                continue;
            case 'S':
-               if (regflags & PMf_LOCALE) {
-                   if (!SIZE_ONLY)
+               if (!SIZE_ONLY) {
+                   if (regflags & PMf_LOCALE)
                        *opnd |= ANYOF_NSPACEL;
-               }
-               else {
-                   for (Class = 0; Class < 256; Class++)
-                       if (!isSPACE(Class))
-                           regset(opnd, Class);
+                   else {
+                       for (Class = 0; Class < 256; Class++)
+                           if (!isSPACE(Class))
+                               ANYOF_SET(opnd, Class);
+                   }
                }
                lastclass = 1234;
                continue;
            case 'd':
-               for (Class = '0'; Class <= '9'; Class++)
-                   regset(opnd, Class);
+               if (!SIZE_ONLY) {
+                   for (Class = '0'; Class <= '9'; Class++)
+                       ANYOF_SET(opnd, Class);
+               }
                lastclass = 1234;
                continue;
            case 'D':
-               for (Class = 0; Class < '0'; Class++)
-                   regset(opnd, Class);
-               for (Class = '9' + 1; Class < 256; Class++)
-                   regset(opnd, Class);
+               if (!SIZE_ONLY) {
+                   for (Class = 0; Class < '0'; Class++)
+                       ANYOF_SET(opnd, Class);
+                   for (Class = '9' + 1; Class < 256; Class++)
+                       ANYOF_SET(opnd, Class);
+               }
                lastclass = 1234;
                continue;
            case 'n':
@@ -2008,13 +2006,31 @@ regclass(void)
                continue;       /* do it next time */
            }
        }
-       for ( ; lastclass <= Class; lastclass++)
-           regset(opnd, lastclass);
+       if (!SIZE_ONLY) {
+           for ( ; lastclass <= Class; lastclass++)
+               ANYOF_SET(opnd, lastclass);
+       }
        lastclass = Class;
     }
     if (*regparse != ']')
        FAIL("unmatched [] in regexp");
     nextchar();
+    /* optimize case-insensitive simple patterns (e.g. /[a-z]/i) */
+    if (!SIZE_ONLY && (*opnd & (0xFF ^ ANYOF_INVERT)) == ANYOF_FOLD) {
+       for (Class = 0; Class < 256; ++Class) {
+           if (ANYOF_TEST(opnd, Class)) {
+               I32 cf = fold[Class];
+               ANYOF_SET(opnd, cf);
+           }
+       }
+       *opnd &= ~ANYOF_FOLD;
+    }
+    /* optimize inverted simple patterns (e.g. [^a-z]) */
+    if (!SIZE_ONLY && (*opnd & 0xFF) == ANYOF_INVERT) {
+       for (Class = 0; Class < 32; ++Class)
+           opnd[1 + Class] ^= 0xFF;
+       *opnd = 0;
+    }
     return ret;
 }
 
@@ -2570,12 +2586,13 @@ pregfree(struct regexp *r)
        Safefree(r->precomp);
     if (r->subbase)
        Safefree(r->subbase);
-    if (r->substrs)
+    if (r->substrs) {
+       if (r->anchored_substr)
+           SvREFCNT_dec(r->anchored_substr);
+       if (r->float_substr)
+           SvREFCNT_dec(r->float_substr);
        Safefree(r->substrs);
-    if (r->anchored_substr)
-       SvREFCNT_dec(r->anchored_substr);
-    if (r->float_substr)
-       SvREFCNT_dec(r->float_substr);
+    }
     if (r->data) {
        int n = r->data->count;
        while (--n >= 0) {