ext/re/re.xs

   1 #if defined(PERL_EXT_RE_DEBUG) && !defined(DEBUGGING)
   2 #  define DEBUGGING
   3 #endif
   4
   5 #define PERL_NO_GET_CONTEXT
   6 #include "EXTERN.h"
   7 #include "perl.h"
   8 #include "XSUB.h"
   9 #include "re_comp.h"
  10
  11
  12 START_EXTERN_C
  13
  14 extern REGEXP*  my_re_compile (pTHX_ const SV * const pattern, const U32 pm_flags);
  15 extern I32      my_regexec (pTHX_ REGEXP * const prog, char* stringarg, char* strend,
  16                             char* strbeg, I32 minend, SV* screamer,
  17                             void* data, U32 flags);
  18
  19 extern char*    my_re_intuit_start (pTHX_ REGEXP * const prog, SV *sv, char *strpos,
  20                                     char *strend, const U32 flags,
  21                                     struct re_scream_pos_data_s *data);
  22 extern SV*      my_re_intuit_string (pTHX_ REGEXP * const prog);
  23
  24 extern void     my_regfree (pTHX_ REGEXP * const r);
  25
  26 extern void     my_reg_numbered_buff_fetch(pTHX_ REGEXP * const rx, const I32 paren,
  27                                            SV * const usesv);
  28 extern void     my_reg_numbered_buff_store(pTHX_ REGEXP * const rx, const I32 paren,
  29                                            SV const * const value);
  30 extern I32      my_reg_numbered_buff_length(pTHX_ REGEXP * const rx,
  31                                             const SV * const sv, const I32 paren);
  32
  33 extern SV*      my_reg_named_buff(pTHX_ REGEXP * const, SV * const, SV * const,
  34                               const U32);
  35 extern SV*      my_reg_named_buff_iter(pTHX_ REGEXP * const rx,
  36                                    const SV * const lastkey, const U32 flags);
  37
  38 extern SV*      my_reg_qr_package(pTHX_ REGEXP * const rx);
  39 #if defined(USE_ITHREADS)
  40 extern void*    my_regdupe (pTHX_ REGEXP * const r, CLONE_PARAMS *param);
  41 #endif
  42
  43 EXTERN_C const struct regexp_engine my_reg_engine;
  44
  45 END_EXTERN_C
  46
  47 const struct regexp_engine my_reg_engine = {
  48         my_re_compile,
  49         my_regexec,
  50         my_re_intuit_start,
  51         my_re_intuit_string,
  52         my_regfree,
  53         my_reg_numbered_buff_fetch,
  54         my_reg_numbered_buff_store,
  55         my_reg_numbered_buff_length,
  56         my_reg_named_buff,
  57         my_reg_named_buff_iter,
  58         my_reg_qr_package,
  59 #if defined(USE_ITHREADS)
  60         my_regdupe
  61 #endif
  62 };
  63
  64 REGEXP *
  65 get_re_arg( pTHX_ SV *sv, U32 flags, MAGIC **mgp) {
  66     MAGIC *mg;
  67     if (sv) {
  68         if (SvMAGICAL(sv))
  69             mg_get(sv);
  70         if (SvROK(sv) &&
  71             (sv = (SV*)SvRV(sv)) &&     /* assign deliberate */
  72             SvTYPE(sv) == SVt_PVMG &&
  73             (mg = mg_find(sv, PERL_MAGIC_qr))) /* assign deliberate */
  74         {
  75             if (mgp) *mgp = mg;
  76             return (REGEXP *)mg->mg_obj;
  77         }
  78     }
  79     if (mgp) *mgp = NULL;
  80     return ((flags && PL_curpm) ? PM_GETRE(PL_curpm) : NULL);
  81 }
  82
  83 MODULE = re     PACKAGE = re
  84
  85 void
  86 install()
  87     PPCODE:
  88         PL_colorset = 0;        /* Allow reinspection of ENV. */
  89         /* PL_debug |= DEBUG_r_FLAG; */
  90         XPUSHs(sv_2mortal(newSViv(PTR2IV(&my_reg_engine))));
  91
  92
  93 void
  94 regexp_pattern(sv)
  95     SV * sv
  96 PROTOTYPE: $
  97 PREINIT:
  98     MAGIC *mg;
  99     REGEXP *re;
 100 PPCODE:
 101 {
 102     /*
 103        Checks if a reference is a regex or not. If the parameter is
 104        not a ref, or is not the result of a qr// then returns false
 105        in scalar context and an empty list in list context.
 106        Otherwise in list context it returns the pattern and the
 107        modifiers, in scalar context it returns the pattern just as it
 108        would if the qr// was stringified normally, regardless as
 109        to the class of the variable and any strigification overloads
 110        on the object.
 111     */
 112
 113     if ( re = get_re_arg( aTHX_ sv, 0, &mg) ) /* assign deliberate */
 114     {
 115         /* Housten, we have a regex! */
 116         SV *pattern;
 117         STRLEN patlen = 0;
 118         STRLEN left = 0;
 119         char reflags[6];
 120
 121         if ( GIMME_V == G_ARRAY ) {
 122             /*
 123                we are in list context so stringify
 124                the modifiers that apply. We ignore "negative
 125                modifiers" in this scenario.
 126             */
 127
 128             char *fptr = INT_PAT_MODS;
 129             char ch;
 130             U16 match_flags = (U16)((re->extflags & PMf_COMPILETIME) >> 12);
 131
 132             while((ch = *fptr++)) {
 133                 if(match_flags & 1) {
 134                     reflags[left++] = ch;
 135                 }
 136                 match_flags >>= 1;
 137             }
 138
 139             pattern = sv_2mortal(newSVpvn(re->precomp,re->prelen));
 140             if (re->extflags & RXf_UTF8) SvUTF8_on(pattern);
 141
 142             /* return the pattern and the modifiers */
 143             XPUSHs(pattern);
 144             XPUSHs(sv_2mortal(newSVpvn(reflags,left)));
 145             XSRETURN(2);
 146         } else {
 147             /* Scalar, so use the string that Perl would return */
 148             /* return the pattern in (?msix:..) format */
 149             pattern = sv_2mortal(newSVpvn(re->wrapped,re->wraplen));
 150             if (re->extflags & RXf_UTF8)
 151                 SvUTF8_on(pattern);
 152             XPUSHs(pattern);
 153             XSRETURN(1);
 154         }
 155     } else {
 156         /* It ain't a regexp folks */
 157         if ( GIMME_V == G_ARRAY ) {
 158             /* return the empty list */
 159             XSRETURN_UNDEF;
 160         } else {
 161             /* Because of the (?:..) wrapping involved in a
 162                stringified pattern it is impossible to get a
 163                result for a real regexp that would evaluate to
 164                false. Therefore we can return PL_sv_no to signify
 165                that the object is not a regex, this means that one
 166                can say
 167
 168                  if (regex($might_be_a_regex) eq '(?:foo)') { }
 169
 170                and not worry about undefined values.
 171             */
 172             XSRETURN_NO;
 173         }
 174     }
 175     /* NOT-REACHED */
 176 }
 177
 178
 179 void
 180 regmust(sv)
 181     SV * sv
 182 PROTOTYPE: $
 183 PREINIT:
 184     REGEXP *re;
 185 PPCODE:
 186 {
 187     if ( re = get_re_arg( aTHX_ sv, 0, 0) ) /* assign deliberate */
 188     {
 189         SV *an = &PL_sv_no;
 190         SV *fl = &PL_sv_no;
 191         if (re->anchored_substr) {
 192             an = newSVsv(re->anchored_substr);
 193         } else if (re->anchored_utf8) {
 194             an = newSVsv(re->anchored_utf8);
 195         }
 196         if (re->float_substr) {
 197             fl = newSVsv(re->float_substr);
 198         } else if (re->float_utf8) {
 199             fl = newSVsv(re->float_utf8);
 200         }
 201         XPUSHs(an);
 202         XPUSHs(fl);
 203         XSRETURN(2);
 204     }
 205     XSRETURN_UNDEF;
 206 }
 207