perldiag: pseudo-hashes are long gone

[perl5.git] / regexec.c

diff --git a/regexec.c b/regexec.c
index 748e047..476a966 100644 (file)
--- a/regexec.c
+++ b/regexec.c
@@ -1333,8 +1333,7 @@ if ((!reginfo || regtry(reginfo, &s))) \
     }                                                          \
     else {                                                     \
        REXEC_FBC_CLASS_SCAN(CoNd);                            \
-    }                                                          \
-    break
+    }
     
 #define REXEC_FBC_CSCAN_PRELOAD(UtFpReLoAd,CoNdUtF8,CoNd)      \
     if (utf8_target) {                                             \
@@ -1343,8 +1342,7 @@ if ((!reginfo || regtry(reginfo, &s))) \
     }                                                          \
     else {                                                     \
        REXEC_FBC_CLASS_SCAN(CoNd);                            \
-    }                                                          \
-    break
+    }
 
 #define REXEC_FBC_CSCAN_TAINT(CoNdUtF8,CoNd)                   \
     PL_reg_flags |= RF_tainted;                                \
@@ -1353,8 +1351,7 @@ if ((!reginfo || regtry(reginfo, &s))) \
     }                                                          \
     else {                                                     \
        REXEC_FBC_CLASS_SCAN(CoNd);                            \
-    }                                                          \
-    break
+    }
 
 #define DUMP_EXEC_POS(li,s,doutf8) \
     dump_exec_pos(li,s,(PL_regeol),(PL_bostr),(PL_reg_starttry),doutf8)
@@ -1676,128 +1673,170 @@ S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s,
                isALNUM_LC_utf8((U8*)s),
                isALNUM_LC(*s)
            );
+           break;
        case ALNUMU:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_PERL_WORD(),
                swash_fetch(RE_utf8_perl_word,(U8*)s, utf8_target),
                 isWORDCHAR_L1((U8) *s)
            );
+           break;
        case ALNUM:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_PERL_WORD(),
                swash_fetch(RE_utf8_perl_word,(U8*)s, utf8_target),
                 isWORDCHAR((U8) *s)
            );
+           break;
        case ALNUMA:
+           /* Don't need to worry about utf8, as it can match only a single
+            * byte invariant character */
            REXEC_FBC_CLASS_SCAN( isWORDCHAR_A(*s));
+           break;
        case NALNUMU:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_PERL_WORD(),
                swash_fetch(RE_utf8_perl_word,(U8*)s, utf8_target),
                 ! isWORDCHAR_L1((U8) *s)
            );
+           break;
        case NALNUM:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_PERL_WORD(),
                !swash_fetch(RE_utf8_perl_word, (U8*)s, utf8_target),
                 ! isALNUM(*s)
            );
+           break;
        case NALNUMA:
-           REXEC_FBC_UTF8_CLASS_SCAN( !isWORDCHAR_A(*s));
+           REXEC_FBC_CSCAN(
+               !isWORDCHAR_A(*s),
+               !isWORDCHAR_A(*s)
+           );
+           break;
        case NALNUML:
            REXEC_FBC_CSCAN_TAINT(
                !isALNUM_LC_utf8((U8*)s),
                !isALNUM_LC(*s)
            );
+           break;
        case SPACEU:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_PERL_SPACE(),
                *s == ' ' || swash_fetch(RE_utf8_perl_space,(U8*)s, utf8_target),
                 isSPACE_L1((U8) *s)
            );
+           break;
        case SPACE:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_PERL_SPACE(),
                *s == ' ' || swash_fetch(RE_utf8_perl_space,(U8*)s, utf8_target),
                 isSPACE((U8) *s)
            );
+           break;
        case SPACEA:
+           /* Don't need to worry about utf8, as it can match only a single
+            * byte invariant character */
            REXEC_FBC_CLASS_SCAN( isSPACE_A(*s));
+           break;
        case SPACEL:
            REXEC_FBC_CSCAN_TAINT(
                isSPACE_LC_utf8((U8*)s),
                isSPACE_LC(*s)
            );
+           break;
        case NSPACEU:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_PERL_SPACE(),
                !( *s == ' ' || swash_fetch(RE_utf8_perl_space,(U8*)s, utf8_target)),
                 ! isSPACE_L1((U8) *s)
            );
+           break;
        case NSPACE:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_PERL_SPACE(),
                !(*s == ' ' || swash_fetch(RE_utf8_perl_space,(U8*)s, utf8_target)),
                 ! isSPACE((U8) *s)
            );
+           break;
        case NSPACEA:
-           REXEC_FBC_UTF8_CLASS_SCAN( !isSPACE_A(*s));
+           REXEC_FBC_CSCAN(
+               !isSPACE_A(*s),
+               !isSPACE_A(*s)
+           );
+           break;
        case NSPACEL:
            REXEC_FBC_CSCAN_TAINT(
                !isSPACE_LC_utf8((U8*)s),
                !isSPACE_LC(*s)
            );
+           break;
        case DIGIT:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_POSIX_DIGIT(),
                swash_fetch(RE_utf8_posix_digit,(U8*)s, utf8_target),
                isDIGIT(*s)
            );
+           break;
        case DIGITA:
+           /* Don't need to worry about utf8, as it can match only a single
+            * byte invariant character */
            REXEC_FBC_CLASS_SCAN( isDIGIT_A(*s));
+           break;
        case DIGITL:
            REXEC_FBC_CSCAN_TAINT(
                isDIGIT_LC_utf8((U8*)s),
                isDIGIT_LC(*s)
            );
+           break;
        case NDIGIT:
            REXEC_FBC_CSCAN_PRELOAD(
                LOAD_UTF8_CHARCLASS_POSIX_DIGIT(),
                !swash_fetch(RE_utf8_posix_digit,(U8*)s, utf8_target),
                !isDIGIT(*s)
            );
+           break;
        case NDIGITA:
-           REXEC_FBC_UTF8_CLASS_SCAN( !isDIGIT_A(*s));
+           REXEC_FBC_CSCAN(
+               !isDIGIT_A(*s),
+               !isDIGIT_A(*s)
+           );
+           break;
        case NDIGITL:
            REXEC_FBC_CSCAN_TAINT(
                !isDIGIT_LC_utf8((U8*)s),
                !isDIGIT_LC(*s)
            );
+           break;
        case LNBREAK:
            REXEC_FBC_CSCAN(
                is_LNBREAK_utf8(s),
                is_LNBREAK_latin1(s)
            );
+           break;
        case VERTWS:
            REXEC_FBC_CSCAN(
                is_VERTWS_utf8(s),
                is_VERTWS_latin1(s)
            );
+           break;
        case NVERTWS:
            REXEC_FBC_CSCAN(
                !is_VERTWS_utf8(s),
                !is_VERTWS_latin1(s)
            );
+           break;
        case HORIZWS:
            REXEC_FBC_CSCAN(
                is_HORIZWS_utf8(s),
                is_HORIZWS_latin1(s)
            );
+           break;
        case NHORIZWS:
            REXEC_FBC_CSCAN(
                !is_HORIZWS_utf8(s),
                !is_HORIZWS_latin1(s)
            );      
+           break;
        case AHOCORASICKC:
        case AHOCORASICK: 
            {
@@ -6774,6 +6813,7 @@ S_reginclass(pTHX_ const regexp * const prog, register const regnode * const n,
                            }
                        }
                    }
+#if 0
                    if (!match) { /* See if the folded version matches */
                        SV** listp;
 
@@ -6842,6 +6882,7 @@ S_reginclass(pTHX_ const regexp * const prog, register const regnode * const n,
                            }
                        }
                    }
+#endif
                }
 
                /* If we allocated a string above, free it */