[perl #41698] [PATCH] v5.8.8 pod2html -- Add <div>..</div> around the outputted INDEX...

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

diff --git a/universal.c b/universal.c
index d07ff2f..69c31f1 100644 (file)
--- a/universal.c
+++ b/universal.c
@@ -62,7 +62,7 @@ S_isa_lookup(pTHX_ HV *stash, const char *name, const HV* const name_stash,
 
     gvp = (GV**)hv_fetchs(stash, "::ISA::CACHE::", FALSE);
 
-    if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (subgen = GvSV(gv))
+    if (gvp && (gv = *gvp) && isGV_with_GP(gv) && (subgen = GvSV(gv))
        && (hv = GvHV(gv)))
     {
        if (SvIV(subgen) == (IV)PL_sub_generation) {
@@ -87,7 +87,7 @@ S_isa_lookup(pTHX_ HV *stash, const char *name, const HV* const name_stash,
 
     gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
 
-    if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (av = GvAV(gv))) {
+    if (gvp && (gv = *gvp) && isGV_with_GP(gv) && (av = GvAV(gv))) {
        if (!hv || !subgen) {
            gvp = (GV**)hv_fetchs(stash, "::ISA::CACHE::", TRUE);
 
@@ -220,6 +220,26 @@ Perl_sv_does(pTHX_ SV *sv, const char *name)
     return does_it;
 }
 
+regexp *
+Perl_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);
+}
+
+
 PERL_XS_EXPORT_C void XS_UNIVERSAL_isa(pTHX_ CV *cv);
 PERL_XS_EXPORT_C void XS_UNIVERSAL_can(pTHX_ CV *cv);
 PERL_XS_EXPORT_C void XS_UNIVERSAL_DOES(pTHX_ CV *cv);
@@ -254,6 +274,12 @@ XS(XS_Internals_hash_seed);
 XS(XS_Internals_rehash_seed);
 XS(XS_Internals_HvREHASH);
 XS(XS_Internals_inc_sub_generation);
+XS(XS_re_is_regexp); 
+XS(XS_re_regname); 
+XS(XS_re_regnames); 
+XS(XS_re_regnames_iterinit);
+XS(XS_re_regnames_iternext);
+XS(XS_re_regnames_count);
 
 void
 Perl_boot_core_UNIVERSAL(pTHX)
@@ -306,6 +332,12 @@ Perl_boot_core_UNIVERSAL(pTHX)
     newXSproto("Internals::HvREHASH", XS_Internals_HvREHASH, file, "\\%");
     newXSproto("Internals::inc_sub_generation",XS_Internals_inc_sub_generation,
               file, "");
+    newXSproto("re::is_regexp", XS_re_is_regexp, file, "$");
+    newXSproto("re::regname", XS_re_regname, file, ";$$$");
+    newXSproto("re::regnames", XS_re_regnames, file, ";$$");
+    newXSproto("re::regnames_iterinit", XS_re_regnames_iterinit, file, ";$");
+    newXSproto("re::regnames_iternext", XS_re_regnames_iternext, file, ";$$");
+    newXSproto("re::regnames_count", XS_re_regnames_count, file, ";$");
 }
 
 
@@ -313,6 +345,7 @@ XS(XS_UNIVERSAL_isa)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
 
     if (items != 2)
        Perl_croak(aTHX_ "Usage: UNIVERSAL::isa(reference, kind)");
@@ -341,6 +374,7 @@ XS(XS_UNIVERSAL_can)
     const char *name;
     SV   *rv;
     HV   *pkg = NULL;
+    PERL_UNUSED_ARG(cv);
 
     if (items != 2)
        Perl_croak(aTHX_ "Usage: UNIVERSAL::can(object-ref, method)");
@@ -379,6 +413,7 @@ XS(XS_UNIVERSAL_DOES)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
 
     if (items != 2)
        Perl_croak(aTHX_ "Usage: invocant->does(kind)");
@@ -403,6 +438,7 @@ XS(XS_UNIVERSAL_VERSION)
     GV *gv;
     SV *sv;
     const char *undef;
+    PERL_UNUSED_ARG(cv);
 
     if (SvROK(ST(0))) {
         sv = (SV*)SvRV(ST(0));
@@ -475,6 +511,7 @@ XS(XS_version_new)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items > 3)
        Perl_croak(aTHX_ "Usage: version::new(class, version)");
     SP -= items;
@@ -510,6 +547,7 @@ XS(XS_version_stringify)
 {
      dVAR;
      dXSARGS;
+     PERL_UNUSED_ARG(cv);
      if (items < 1)
          Perl_croak(aTHX_ "Usage: version::stringify(lobj, ...)");
      SP -= items;
@@ -533,6 +571,7 @@ XS(XS_version_numify)
 {
      dVAR;
      dXSARGS;
+     PERL_UNUSED_ARG(cv);
      if (items < 1)
          Perl_croak(aTHX_ "Usage: version::numify(lobj, ...)");
      SP -= items;
@@ -556,6 +595,7 @@ XS(XS_version_normal)
 {
      dVAR;
      dXSARGS;
+     PERL_UNUSED_ARG(cv);
      if (items < 1)
          Perl_croak(aTHX_ "Usage: version::normal(lobj, ...)");
      SP -= items;
@@ -579,6 +619,7 @@ XS(XS_version_vcmp)
 {
      dVAR;
      dXSARGS;
+     PERL_UNUSED_ARG(cv);
      if (items < 1)
          Perl_croak(aTHX_ "Usage: version::vcmp(lobj, ...)");
      SP -= items;
@@ -624,6 +665,7 @@ XS(XS_version_boolean)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items < 1)
        Perl_croak(aTHX_ "Usage: version::boolean(lobj, ...)");
     SP -= items;
@@ -642,6 +684,7 @@ XS(XS_version_noop)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items < 1)
        Perl_croak(aTHX_ "Usage: version::noop(lobj, ...)");
     if (sv_derived_from(ST(0), "version"))
@@ -657,6 +700,7 @@ XS(XS_version_is_alpha)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items != 1)
        Perl_croak(aTHX_ "Usage: version::is_alpha(lobj)");
     SP -= items;
@@ -677,6 +721,7 @@ XS(XS_version_qv)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items != 1)
        Perl_croak(aTHX_ "Usage: version::qv(ver)");
     SP -= items;
@@ -721,6 +766,7 @@ XS(XS_utf8_is_utf8)
 {
      dVAR;
      dXSARGS;
+     PERL_UNUSED_ARG(cv);
      if (items != 1)
          Perl_croak(aTHX_ "Usage: utf8::is_utf8(sv)");
      else {
@@ -737,6 +783,7 @@ XS(XS_utf8_valid)
 {
      dVAR;
      dXSARGS;
+     PERL_UNUSED_ARG(cv);
      if (items != 1)
          Perl_croak(aTHX_ "Usage: utf8::valid(sv)");
     else {
@@ -755,6 +802,7 @@ XS(XS_utf8_encode)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items != 1)
        Perl_croak(aTHX_ "Usage: utf8::encode(sv)");
     sv_utf8_encode(ST(0));
@@ -765,6 +813,7 @@ XS(XS_utf8_decode)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items != 1)
        Perl_croak(aTHX_ "Usage: utf8::decode(sv)");
     else {
@@ -780,6 +829,7 @@ XS(XS_utf8_upgrade)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items != 1)
        Perl_croak(aTHX_ "Usage: utf8::upgrade(sv)");
     else {
@@ -797,6 +847,7 @@ XS(XS_utf8_downgrade)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items < 1 || items > 2)
        Perl_croak(aTHX_ "Usage: utf8::downgrade(sv, failok=0)");
     else {
@@ -815,6 +866,7 @@ XS(XS_utf8_native_to_unicode)
  dVAR;
  dXSARGS;
  const UV uv = SvUV(ST(0));
+ PERL_UNUSED_ARG(cv);
 
  if (items > 1)
      Perl_croak(aTHX_ "Usage: utf8::native_to_unicode(sv)");
@@ -828,6 +880,7 @@ XS(XS_utf8_unicode_to_native)
  dVAR;
  dXSARGS;
  const UV uv = SvUV(ST(0));
+ PERL_UNUSED_ARG(cv);
 
  if (items > 1)
      Perl_croak(aTHX_ "Usage: utf8::unicode_to_native(sv)");
@@ -841,6 +894,7 @@ XS(XS_Internals_SvREADONLY) /* This is dangerous stuff. */
     dVAR;
     dXSARGS;
     SV * const sv = SvRV(ST(0));
+    PERL_UNUSED_ARG(cv);
 
     if (items == 1) {
         if (SvREADONLY(sv))
@@ -867,6 +921,7 @@ XS(XS_Internals_SvREFCNT)   /* This is dangerous stuff. */
     dVAR;
     dXSARGS;
     SV * const sv = SvRV(ST(0));
+    PERL_UNUSED_ARG(cv);
 
     if (items == 1)
         XSRETURN_IV(SvREFCNT(sv) - 1); /* Minus the ref created for us. */
@@ -882,6 +937,7 @@ XS(XS_Internals_hv_clear_placehold)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
 
     if (items != 1)
        Perl_croak(aTHX_ "Usage: UNIVERSAL::hv_clear_placeholders(hv)");
@@ -902,6 +958,7 @@ XS(XS_PerlIO_get_layers)
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (items < 1 || items % 2 == 0)
        Perl_croak(aTHX_ "Usage: PerlIO_get_layers(filehandle[,args])");
 #ifdef USE_PERLIO
@@ -1048,6 +1105,7 @@ XS(XS_Internals_HvREHASH) /* Subject to change  */
 {
     dVAR;
     dXSARGS;
+    PERL_UNUSED_ARG(cv);
     if (SvROK(ST(0))) {
        const HV * const hv = (HV *) SvRV(ST(0));
        if (items == 1 && SvTYPE(hv) == SVt_PVHV) {
@@ -1072,6 +1130,271 @@ XS(XS_Internals_inc_sub_generation)
     XSRETURN_EMPTY;
 }
 
+XS(XS_re_is_regexp)
+{
+    dVAR; 
+    dXSARGS;
+    if (items != 1)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "re::is_regexp", "sv");
+    PERL_UNUSED_VAR(cv); /* -W */
+    PERL_UNUSED_VAR(ax); /* -Wall */
+    SP -= items;
+    {
+       SV *    sv = ST(0);
+        if ( Perl_get_re_arg( aTHX_ sv, 0, NULL ) ) 
+        {
+            XSRETURN_YES;
+        } else {
+            XSRETURN_NO;
+        }
+        /* NOTREACHED */        
+       PUTBACK;
+       return;
+    }
+}
+
+XS(XS_re_regname)
+{
+
+    dVAR; 
+    dXSARGS;
+    if (items < 1 || items > 3)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "re::regname", "sv, qr = NULL, all = NULL");
+    PERL_UNUSED_VAR(cv); /* -W */
+    PERL_UNUSED_VAR(ax); /* -Wall */
+    SP -= items;
+    {
+       SV *    sv = ST(0);
+       SV *    qr;
+       SV *    all;
+        regexp *re = NULL;
+        SV *bufs = NULL;
+
+       if (items < 2)
+           qr = NULL;
+       else {
+           qr = ST(1);
+       }
+
+       if (items < 3)
+           all = NULL;
+       else {
+           all = ST(2);
+       }
+        {
+            re = Perl_get_re_arg( aTHX_ qr, 1, NULL);
+            if (SvPOK(sv) && re && re->paren_names) {
+                bufs = CALLREG_NAMEDBUF(re,sv,all && SvTRUE(all));
+                if (bufs) {
+                    if (all && SvTRUE(all))
+                        XPUSHs(newRV(bufs));
+                    else
+                        XPUSHs(SvREFCNT_inc(bufs));
+                    XSRETURN(1);
+                }
+            }
+            XSRETURN_UNDEF;
+        }
+       PUTBACK;
+       return;
+    }
+}
+
+XS(XS_re_regnames)
+{
+    dVAR; 
+    dXSARGS;
+    if (items < 0 || items > 2)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "re::regnames", "sv = NULL, all = NULL");
+    PERL_UNUSED_VAR(cv); /* -W */
+    PERL_UNUSED_VAR(ax); /* -Wall */
+    SP -= items;
+    {
+       SV *    sv;
+       SV *    all;
+        regexp *re = NULL;
+        IV count = 0;
+
+       if (items < 1)
+           sv = NULL;
+       else {
+           sv = ST(0);
+       }
+
+       if (items < 2)
+           all = NULL;
+       else {
+           all = ST(1);
+       }
+        {
+            re = Perl_get_re_arg( aTHX_  sv, 1, NULL );
+            if (re && re->paren_names) {
+                HV *hv= re->paren_names;
+                (void)hv_iterinit(hv);
+                while (1) {
+                    HE *temphe = hv_iternext_flags(hv,0);
+                    if (temphe) {
+                        IV i;
+                        IV parno = 0;
+                        SV* sv_dat = HeVAL(temphe);
+                        I32 *nums = (I32*)SvPVX(sv_dat);
+                        for ( i = 0; i < SvIVX(sv_dat); i++ ) {
+                            if ((I32)(re->lastcloseparen) >= nums[i] &&
+                                re->startp[nums[i]] != -1 &&
+                                re->endp[nums[i]] != -1)
+                            {
+                                parno = nums[i];
+                                break;
+                            }
+                        }
+                        if (parno || (all && SvTRUE(all))) {
+                            STRLEN len;
+                            char *pv = HePV(temphe, len);
+                            if ( GIMME_V == G_ARRAY ) 
+                                XPUSHs(newSVpvn(pv,len));
+                            count++;
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            }
+            if ( GIMME_V == G_ARRAY ) 
+                XSRETURN(count);
+            else 
+                XSRETURN_UNDEF;
+        }    
+       PUTBACK;
+       return;
+    }
+}
+
+
+XS(XS_re_regnames_iterinit)
+{
+    dVAR; 
+    dXSARGS;
+    if (items < 0 || items > 1)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "re::regnames_iterinit", "sv = NULL");
+    PERL_UNUSED_VAR(cv); /* -W */
+    PERL_UNUSED_VAR(ax); /* -Wall */
+    SP -= items;
+    {
+       SV *    sv;
+        regexp *re = NULL;
+
+       if (items < 1)
+           sv = NULL;
+       else {
+           sv = ST(0);
+       }
+        {
+            re = Perl_get_re_arg( aTHX_  sv, 1, NULL );
+            if (re && re->paren_names) {
+                (void)hv_iterinit(re->paren_names);
+                XPUSHs(newSViv(HvTOTALKEYS(re->paren_names)));
+            } else {
+                XSRETURN_UNDEF;
+            }  
+        }
+       PUTBACK;
+       return;
+    }
+}
+
+
+XS(XS_re_regnames_iternext)
+{
+    dVAR; 
+    dXSARGS;
+    if (items < 0 || items > 2)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "re::regnames_iternext", "sv = NULL, all = NULL");
+    PERL_UNUSED_VAR(cv); /* -W */
+    PERL_UNUSED_VAR(ax); /* -Wall */
+    SP -= items;
+    {
+       SV *    sv;
+       SV *    all;
+        regexp *re;
+
+       if (items < 1)
+           sv = NULL;
+       else {
+           sv = ST(0);
+       }
+
+       if (items < 2)
+           all = NULL;
+       else {
+           all = ST(1);
+       }
+        {
+            re = Perl_get_re_arg( aTHX_  sv, 1, NULL ); 
+            if (re && re->paren_names) {
+                HV *hv= re->paren_names;
+                while (1) {
+                    HE *temphe = hv_iternext_flags(hv,0);
+                    if (temphe) {
+                        IV i;
+                        IV parno = 0;
+                        SV* sv_dat = HeVAL(temphe);
+                        I32 *nums = (I32*)SvPVX(sv_dat);
+                        for ( i = 0; i < SvIVX(sv_dat); i++ ) {
+                            if ((I32)(re->lastcloseparen) >= nums[i] &&
+                                re->startp[nums[i]] != -1 &&
+                                re->endp[nums[i]] != -1)
+                            {
+                                parno = nums[i];
+                                break;
+                            }
+                        }
+                        if (parno || (all && SvTRUE(all))) {
+                            STRLEN len;
+                            char *pv = HePV(temphe, len);
+                            XPUSHs(newSVpvn(pv,len));
+                            XSRETURN(1);    
+                        }
+                    } else {
+                        break;
+                    }
+                }
+            }
+            XSRETURN_UNDEF;
+        }    
+       PUTBACK;
+       return;
+    }
+}
+
+
+XS(XS_re_regnames_count)
+{
+    SV *       sv;
+    regexp *re = NULL;
+    dVAR; 
+    dXSARGS;
+
+    if (items < 0 || items > 1)
+       Perl_croak(aTHX_ "Usage: %s(%s)", "re::regnames_count", "sv = NULL");
+    PERL_UNUSED_VAR(cv); /* -W */
+    PERL_UNUSED_VAR(ax); /* -Wall */
+    SP -= items;
+    if (items < 1)
+        sv = NULL;
+    else {
+        sv = ST(0);
+    }
+    re = Perl_get_re_arg( aTHX_  sv, 1, NULL );
+    if (re && re->paren_names) {
+        XPUSHs(newSViv(HvTOTALKEYS(re->paren_names)));
+    } else {
+        XSRETURN_UNDEF;
+    }  
+    PUTBACK;
+    return;
+}
+
+
 /*
  * Local variables:
  * c-indentation-style: bsd