Retract the mergesort code, way too incompatible licensing
[perl.git] / universal.c
1 #include "EXTERN.h"
2 #define PERL_IN_UNIVERSAL_C
3 #include "perl.h"
4
5 /*
6  * Contributed by Graham Barr  <Graham.Barr@tiuk.ti.com>
7  * The main guts of traverse_isa was actually copied from gv_fetchmeth
8  */
9
10 STATIC SV *
11 S_isa_lookup(pTHX_ HV *stash, const char *name, int len, int level)
12 {
13     AV* av;
14     GV* gv;
15     GV** gvp;
16     HV* hv = Nullhv;
17     SV* subgen = Nullsv;
18
19     if (!stash)
20         return &PL_sv_undef;
21
22     if (strEQ(HvNAME(stash), name))
23         return &PL_sv_yes;
24
25     if (level > 100)
26         Perl_croak(aTHX_ "Recursive inheritance detected in package '%s'",
27                    HvNAME(stash));
28
29     gvp = (GV**)hv_fetch(stash, "::ISA::CACHE::", 14, FALSE);
30
31     if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (subgen = GvSV(gv))
32         && (hv = GvHV(gv)))
33     {
34         if (SvIV(subgen) == PL_sub_generation) {
35             SV* sv;
36             SV** svp = (SV**)hv_fetch(hv, name, len, FALSE);
37             if (svp && (sv = *svp) != (SV*)&PL_sv_undef) {
38                 DEBUG_o( Perl_deb(aTHX_ "Using cached ISA %s for package %s\n",
39                                   name, HvNAME(stash)) );
40                 return sv;
41             }
42         }
43         else {
44             DEBUG_o( Perl_deb(aTHX_ "ISA Cache in package %s is stale\n",
45                               HvNAME(stash)) );
46             hv_clear(hv);
47             sv_setiv(subgen, PL_sub_generation);
48         }
49     }
50
51     gvp = (GV**)hv_fetch(stash,"ISA",3,FALSE);
52
53     if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (av = GvAV(gv))) {
54         if (!hv || !subgen) {
55             gvp = (GV**)hv_fetch(stash, "::ISA::CACHE::", 14, TRUE);
56
57             gv = *gvp;
58
59             if (SvTYPE(gv) != SVt_PVGV)
60                 gv_init(gv, stash, "::ISA::CACHE::", 14, TRUE);
61
62             if (!hv)
63                 hv = GvHVn(gv);
64             if (!subgen) {
65                 subgen = newSViv(PL_sub_generation);
66                 GvSV(gv) = subgen;
67             }
68         }
69         if (hv) {
70             SV** svp = AvARRAY(av);
71             /* NOTE: No support for tied ISA */
72             I32 items = AvFILLp(av) + 1;
73             while (items--) {
74                 SV* sv = *svp++;
75                 HV* basestash = gv_stashsv(sv, FALSE);
76                 if (!basestash) {
77                     dTHR;
78                     if (ckWARN(WARN_MISC))
79                         Perl_warner(aTHX_ WARN_SYNTAX,
80                              "Can't locate package %s for @%s::ISA",
81                             SvPVX(sv), HvNAME(stash));
82                     continue;
83                 }
84                 if (&PL_sv_yes == isa_lookup(basestash, name, len, level + 1)) {
85                     (void)hv_store(hv,name,len,&PL_sv_yes,0);
86                     return &PL_sv_yes;
87                 }
88             }
89             (void)hv_store(hv,name,len,&PL_sv_no,0);
90         }
91     }
92
93     return boolSV(strEQ(name, "UNIVERSAL"));
94 }
95
96 /*
97 =for apidoc sv_derived_from
98
99 Returns a boolean indicating whether the SV is derived from the specified
100 class.  This is the function that implements C<UNIVERSAL::isa>.  It works
101 for class names as well as for objects.
102
103 =cut
104 */
105
106 bool
107 Perl_sv_derived_from(pTHX_ SV *sv, const char *name)
108 {
109     char *type;
110     HV *stash;
111
112     stash = Nullhv;
113     type = Nullch;
114
115     if (SvGMAGICAL(sv))
116         mg_get(sv) ;
117
118     if (SvROK(sv)) {
119         sv = SvRV(sv);
120         type = sv_reftype(sv,0);
121         if (SvOBJECT(sv))
122             stash = SvSTASH(sv);
123     }
124     else {
125         stash = gv_stashsv(sv, FALSE);
126     }
127
128     return (type && strEQ(type,name)) ||
129             (stash && isa_lookup(stash, name, strlen(name), 0) == &PL_sv_yes)
130         ? TRUE
131         : FALSE ;
132 }
133
134 void XS_UNIVERSAL_isa(pTHXo_ CV *cv);
135 void XS_UNIVERSAL_can(pTHXo_ CV *cv);
136 void XS_UNIVERSAL_VERSION(pTHXo_ CV *cv);
137
138 void
139 Perl_boot_core_UNIVERSAL(pTHX)
140 {
141     char *file = __FILE__;
142
143     newXS("UNIVERSAL::isa",             XS_UNIVERSAL_isa,         file);
144     newXS("UNIVERSAL::can",             XS_UNIVERSAL_can,         file);
145     newXS("UNIVERSAL::VERSION",         XS_UNIVERSAL_VERSION,     file);
146 }
147
148 #include "XSUB.h"
149
150 XS(XS_UNIVERSAL_isa)
151 {
152     dXSARGS;
153     SV *sv;
154     char *name;
155     STRLEN n_a;
156
157     if (items != 2)
158         Perl_croak(aTHX_ "Usage: UNIVERSAL::isa(reference, kind)");
159
160     sv = ST(0);
161
162     if (SvGMAGICAL(sv))
163         mg_get(sv);
164
165     if (!SvOK(sv) || !(SvROK(sv) || (SvPOK(sv) && SvCUR(sv))))
166         XSRETURN_UNDEF;
167
168     name = (char *)SvPV(ST(1),n_a);
169
170     ST(0) = boolSV(sv_derived_from(sv, name));
171     XSRETURN(1);
172 }
173
174 XS(XS_UNIVERSAL_can)
175 {
176     dXSARGS;
177     SV   *sv;
178     char *name;
179     SV   *rv;
180     HV   *pkg = NULL;
181     STRLEN n_a;
182
183     if (items != 2)
184         Perl_croak(aTHX_ "Usage: UNIVERSAL::can(object-ref, method)");
185
186     sv = ST(0);
187
188     if (SvGMAGICAL(sv))
189         mg_get(sv);
190
191     if (!SvOK(sv) || !(SvROK(sv) || (SvPOK(sv) && SvCUR(sv))))
192         XSRETURN_UNDEF;
193
194     name = (char *)SvPV(ST(1),n_a);
195     rv = &PL_sv_undef;
196
197     if (SvROK(sv)) {
198         sv = (SV*)SvRV(sv);
199         if (SvOBJECT(sv))
200             pkg = SvSTASH(sv);
201     }
202     else {
203         pkg = gv_stashsv(sv, FALSE);
204     }
205
206     if (pkg) {
207         GV *gv = gv_fetchmethod_autoload(pkg, name, FALSE);
208         if (gv && isGV(gv))
209             rv = sv_2mortal(newRV((SV*)GvCV(gv)));
210     }
211
212     ST(0) = rv;
213     XSRETURN(1);
214 }
215
216 XS(XS_UNIVERSAL_VERSION)
217 {
218     dXSARGS;
219     HV *pkg;
220     GV **gvp;
221     GV *gv;
222     SV *sv;
223     char *undef;
224
225     if (SvROK(ST(0))) {
226         sv = (SV*)SvRV(ST(0));
227         if (!SvOBJECT(sv))
228             Perl_croak(aTHX_ "Cannot find version of an unblessed reference");
229         pkg = SvSTASH(sv);
230     }
231     else {
232         pkg = gv_stashsv(ST(0), FALSE);
233     }
234
235     gvp = pkg ? (GV**)hv_fetch(pkg,"VERSION",7,FALSE) : Null(GV**);
236
237     if (gvp && isGV(gv = *gvp) && SvOK(sv = GvSV(gv))) {
238         SV *nsv = sv_newmortal();
239         sv_setsv(nsv, sv);
240         sv = nsv;
241         undef = Nullch;
242     }
243     else {
244         sv = (SV*)&PL_sv_undef;
245         undef = "(undef)";
246     }
247
248     if (items > 1) {
249         STRLEN len;
250         SV *req = ST(1);
251
252         if (undef)
253             Perl_croak(aTHX_ "%s does not define $%s::VERSION--version check failed",
254                        HvNAME(pkg), HvNAME(pkg));
255
256         if (!SvNIOK(sv) && SvPOK(sv)) {
257             char *str = SvPVx(sv,len);
258             while (len) {
259                 --len;
260                 /* XXX could DWIM "1.2.3" here */
261                 if (!isDIGIT(str[len]) && str[len] != '.' && str[len] != '_')
262                     break;
263             }
264             if (len) {
265                 if (SvNOK(req) && SvPOK(req)) {
266                     /* they said C<use Foo v1.2.3> and $Foo::VERSION
267                      * doesn't look like a float: do string compare */
268                     if (sv_cmp(req,sv) == 1) {
269                         Perl_croak(aTHX_ "%s v%vd required--"
270                                    "this is only v%vd",
271                                    HvNAME(pkg), req, sv);
272                     }
273                     goto finish;
274                 }
275                 /* they said C<use Foo 1.002_003> and $Foo::VERSION
276                  * doesn't look like a float: force numeric compare */
277                 (void)SvUPGRADE(sv, SVt_PVNV);
278                 SvNVX(sv) = str_to_version(sv);
279                 SvPOK_off(sv);
280                 SvNOK_on(sv);
281             }
282         }
283         /* if we get here, we're looking for a numeric comparison,
284          * so force the required version into a float, even if they
285          * said C<use Foo v1.2.3> */
286         if (SvNOK(req) && SvPOK(req)) {
287             NV n = SvNV(req);
288             req = sv_newmortal();
289             sv_setnv(req, n);
290         }
291
292         if (SvNV(req) > SvNV(sv))
293             Perl_croak(aTHX_ "%s version %s required--this is only version %s",
294                   HvNAME(pkg), SvPV(req,len), SvPV(sv,len));
295     }
296
297 finish:
298     ST(0) = sv;
299
300     XSRETURN(1);
301 }
302