Abolish wrapped in struct regexp - store the wrapped pattern pointer

[p5sagit/p5-mst-13.2.git] / ext / re / re.xs

diff --git a/ext/re/re.xs b/ext/re/re.xs
index aa87bb6..dc73b75 100644 (file)
--- a/ext/re/re.xs
+++ b/ext/re/re.xs
@@ -11,22 +11,33 @@
 
 START_EXTERN_C
 
-extern regexp* my_re_compile (pTHX_ char* exp, char* xend, U32 pm_flags);
-extern I32     my_regexec (pTHX_ regexp* prog, char* stringarg, char* strend,
+extern REGEXP* my_re_compile (pTHX_ const SV * const pattern, const U32 pm_flags);
+extern I32     my_regexec (pTHX_ REGEXP * const prog, char* stringarg, char* strend,
                            char* strbeg, I32 minend, SV* screamer,
                            void* data, U32 flags);
 
-extern char*   my_re_intuit_start (pTHX_ regexp *prog, SV *sv, char *strpos,
-                                   char *strend, U32 flags,
+extern char*   my_re_intuit_start (pTHX_ REGEXP * const prog, SV *sv, char *strpos,
+                                   char *strend, const U32 flags,
                                    struct re_scream_pos_data_s *data);
-extern SV*     my_re_intuit_string (pTHX_ regexp *prog);
+extern SV*     my_re_intuit_string (pTHX_ REGEXP * const prog);
 
-extern void    my_regfree (pTHX_ struct regexp* r);
-extern SV*      my_reg_numbered_buff_get(pTHX_ const REGEXP * const rx, I32 paren, SV* usesv);
-extern SV*      my_reg_named_buff_get(pTHX_ const REGEXP * const rx, SV* namesv, U32 flags);
-extern SV*      my_reg_qr_pkg(pTHX_ const REGEXP * const rx);
+extern void    my_regfree (pTHX_ REGEXP * const r);
+
+extern void    my_reg_numbered_buff_fetch(pTHX_ REGEXP * const rx, const I32 paren,
+                                          SV * const usesv);
+extern void    my_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren,
+                                          SV const * const value);
+extern I32     my_reg_numbered_buff_length(pTHX_ REGEXP * const rx,
+                                           const SV * const sv, const I32 paren);
+
+extern SV*     my_reg_named_buff(pTHX_ REGEXP * const, SV * const, SV * const,
+                              const U32);
+extern SV*     my_reg_named_buff_iter(pTHX_ REGEXP * const rx,
+                                   const SV * const lastkey, const U32 flags);
+
+extern SV*      my_reg_qr_package(pTHX_ REGEXP * const rx);
 #if defined(USE_ITHREADS)
-extern void*   my_regdupe (pTHX_ const regexp *r, CLONE_PARAMS *param);
+extern void*   my_regdupe (pTHX_ REGEXP * const r, CLONE_PARAMS *param);
 #endif
 
 EXTERN_C const struct regexp_engine my_reg_engine;
@@ -39,33 +50,17 @@ const struct regexp_engine my_reg_engine = {
         my_re_intuit_start, 
         my_re_intuit_string, 
         my_regfree, 
-        my_reg_numbered_buff_get,
-        my_reg_named_buff_get,
-        my_reg_qr_pkg,
+        my_reg_numbered_buff_fetch,
+        my_reg_numbered_buff_store,
+        my_reg_numbered_buff_length,
+        my_reg_named_buff,
+        my_reg_named_buff_iter,
+        my_reg_qr_package,
 #if defined(USE_ITHREADS)
         my_regdupe 
 #endif
 };
 
-regexp *
-get_re_arg( pTHX_ SV *sv, U32 flags, MAGIC **mgp) {
-    MAGIC *mg;
-    if (sv) {
-        if (SvMAGICAL(sv))
-            mg_get(sv);
-        if (SvROK(sv) &&
-            (sv = (SV*)SvRV(sv)) &&     /* assign deliberate */
-            SvTYPE(sv) == SVt_PVMG &&
-            (mg = mg_find(sv, PERL_MAGIC_qr))) /* assign deliberate */
-        {        
-            if (mgp) *mgp = mg;
-            return (regexp *)mg->mg_obj;       
-        }
-    }    
-    if (mgp) *mgp = NULL;
-    return ((flags && PL_curpm) ? PM_GETRE(PL_curpm) : NULL);
-}
-
 MODULE = re    PACKAGE = re
 
 void
@@ -81,8 +76,7 @@ regexp_pattern(sv)
     SV * sv
 PROTOTYPE: $
 PREINIT:
-    MAGIC *mg;
-    regexp *re;
+    REGEXP *re;
 PPCODE:
 {
     /*
@@ -96,7 +90,7 @@ PPCODE:
        on the object. 
     */
 
-    if ( re = get_re_arg( aTHX_ sv, 0, &mg) ) /* assign deliberate */
+    if ((re = SvRX(sv))) /* assign deliberate */
     {
         /* Housten, we have a regex! */
         SV *pattern;
@@ -111,9 +105,10 @@ PPCODE:
                modifiers" in this scenario. 
             */
 
-            char *fptr = INT_PAT_MODS;
+            const char *fptr = INT_PAT_MODS;
             char ch;
-            U16 match_flags = (U16)((re->extflags & PMf_COMPILETIME) >> 12);
+            U16 match_flags = (U16)((RX_EXTFLAGS(re) & PMf_COMPILETIME)
+                                   >> RXf_PMf_STD_PMMOD_SHIFT);
 
             while((ch = *fptr++)) {
                 if(match_flags & 1) {
@@ -122,8 +117,8 @@ PPCODE:
                 match_flags >>= 1;
             }
 
-            pattern = sv_2mortal(newSVpvn(re->precomp,re->prelen));
-            if (re->extflags & RXf_UTF8) SvUTF8_on(pattern);
+            pattern = sv_2mortal(newSVpvn(RX_PRECOMP(re),RX_PRELEN(re)));
+            if (RX_EXTFLAGS(re) & RXf_UTF8) SvUTF8_on(pattern);
 
             /* return the pattern and the modifiers */
             XPUSHs(pattern);
@@ -132,8 +127,8 @@ PPCODE:
         } else {
             /* Scalar, so use the string that Perl would return */
             /* return the pattern in (?msix:..) format */
-            pattern = sv_2mortal(newSVpvn(re->wrapped,re->wraplen));
-            if (re->extflags & RXf_UTF8) 
+            pattern = sv_2mortal(newSVpvn(RX_WRAPPED(re),RX_WRAPLEN(re)));
+            if (RX_EXTFLAGS(re) & RXf_UTF8) 
                 SvUTF8_on(pattern);
             XPUSHs(pattern);
             XSRETURN(1);
@@ -167,22 +162,22 @@ regmust(sv)
     SV * sv
 PROTOTYPE: $
 PREINIT:
-    regexp *re;
+    REGEXP *re;
 PPCODE:
 {
-    if ( re = get_re_arg( aTHX_ sv, 0, 0) ) /* assign deliberate */
+    if ((re = SvRX(sv))) /* assign deliberate */
     {
         SV *an = &PL_sv_no;
         SV *fl = &PL_sv_no;
-        if (re->anchored_substr) {
-            an = newSVsv(re->anchored_substr);
-        } else if (re->anchored_utf8) {
-            an = newSVsv(re->anchored_utf8);
+        if (RX_ANCHORED_SUBSTR(re)) {
+            an = newSVsv(RX_ANCHORED_SUBSTR(re));
+        } else if (RX_ANCHORED_UTF8(re)) {
+            an = newSVsv(RX_ANCHORED_UTF8(re));
         }
-        if (re->float_substr) {
-            fl = newSVsv(re->float_substr);
-        } else if (re->float_utf8) {
-            fl = newSVsv(re->float_utf8);
+        if (RX_FLOAT_SUBSTR(re)) {
+            fl = newSVsv(RX_FLOAT_SUBSTR(re));
+        } else if (RX_FLOAT_UTF8(re)) {
+            fl = newSVsv(RX_FLOAT_UTF8(re));
         }
         XPUSHs(an);
         XPUSHs(fl);