source: trunk/essentials/dev-lang/perl/pp.c@ 3184

Last change on this file since 3184 was 3181, checked in by bird, 19 years ago

perl 5.8.8
File size: 104.0 KB
Line 
1/* pp.c
2 *
3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 * 2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others
5 *
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
8 *
9 */
10
11/*
12 * "It's a big house this, and very peculiar. Always a bit more to discover,
13 * and no knowing what you'll find around a corner. And Elves, sir!" --Samwise
14 */
15
16/* This file contains general pp ("push/pop") functions that execute the
17 * opcodes that make up a perl program. A typical pp function expects to
18 * find its arguments on the stack, and usually pushes its results onto
19 * the stack, hence the 'pp' terminology. Each OP structure contains
20 * a pointer to the relevant pp_foo() function.
21 */
22
23#include "EXTERN.h"
24#define PERL_IN_PP_C
25#include "perl.h"
26#include "keywords.h"
27
28#include "reentr.h"
29
30/* XXX I can't imagine anyone who doesn't have this actually _needs_
31 it, since pid_t is an integral type.
32 --AD 2/20/1998
33*/
34#ifdef NEED_GETPID_PROTO
35extern Pid_t getpid (void);
36#endif
37
38/*
39 * Some BSDs and Cygwin default to POSIX math instead of IEEE.
40 * This switches them over to IEEE.
41 */
42#if defined(LIBM_LIB_VERSION)
43 _LIB_VERSION_TYPE _LIB_VERSION = _IEEE_;
44#endif
45
46/* variations on pp_null */
47
48PP(pp_stub)
49{
50 dSP;
51 if (GIMME_V == G_SCALAR)
52 XPUSHs(&PL_sv_undef);
53 RETURN;
54}
55
56PP(pp_scalar)
57{
58 return NORMAL;
59}
60
61/* Pushy stuff. */
62
63PP(pp_padav)
64{
65 dSP; dTARGET;
66 I32 gimme;
67 if (PL_op->op_private & OPpLVAL_INTRO)
68 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
69 EXTEND(SP, 1);
70 if (PL_op->op_flags & OPf_REF) {
71 PUSHs(TARG);
72 RETURN;
73 } else if (LVRET) {
74 if (GIMME == G_SCALAR)
75 Perl_croak(aTHX_ "Can't return array to lvalue scalar context");
76 PUSHs(TARG);
77 RETURN;
78 }
79 gimme = GIMME_V;
80 if (gimme == G_ARRAY) {
81 const I32 maxarg = AvFILL((AV*)TARG) + 1;
82 EXTEND(SP, maxarg);
83 if (SvMAGICAL(TARG)) {
84 U32 i;
85 for (i=0; i < (U32)maxarg; i++) {
86 SV ** const svp = av_fetch((AV*)TARG, i, FALSE);
87 SP[i+1] = (svp) ? *svp : &PL_sv_undef;
88 }
89 }
90 else {
91 Copy(AvARRAY((AV*)TARG), SP+1, maxarg, SV*);
92 }
93 SP += maxarg;
94 }
95 else if (gimme == G_SCALAR) {
96 SV* const sv = sv_newmortal();
97 const I32 maxarg = AvFILL((AV*)TARG) + 1;
98 sv_setiv(sv, maxarg);
99 PUSHs(sv);
100 }
101 RETURN;
102}
103
104PP(pp_padhv)
105{
106 dSP; dTARGET;
107 I32 gimme;
108
109 XPUSHs(TARG);
110 if (PL_op->op_private & OPpLVAL_INTRO)
111 SAVECLEARSV(PAD_SVl(PL_op->op_targ));
112 if (PL_op->op_flags & OPf_REF)
113 RETURN;
114 else if (LVRET) {
115 if (GIMME == G_SCALAR)
116 Perl_croak(aTHX_ "Can't return hash to lvalue scalar context");
117 RETURN;
118 }
119 gimme = GIMME_V;
120 if (gimme == G_ARRAY) {
121 RETURNOP(do_kv());
122 }
123 else if (gimme == G_SCALAR) {
124 SV* const sv = Perl_hv_scalar(aTHX_ (HV*)TARG);
125 SETs(sv);
126 }
127 RETURN;
128}
129
130PP(pp_padany)
131{
132 DIE(aTHX_ "NOT IMPL LINE %d",__LINE__);
133}
134
135/* Translations. */
136
137PP(pp_rv2gv)
138{
139 dSP; dTOPss;
140
141 if (SvROK(sv)) {
142 wasref:
143 tryAMAGICunDEREF(to_gv);
144
145 sv = SvRV(sv);
146 if (SvTYPE(sv) == SVt_PVIO) {
147 GV * const gv = (GV*) sv_newmortal();
148 gv_init(gv, 0, "", 0, 0);
149 GvIOp(gv) = (IO *)sv;
150 (void)SvREFCNT_inc(sv);
151 sv = (SV*) gv;
152 }
153 else if (SvTYPE(sv) != SVt_PVGV)
154 DIE(aTHX_ "Not a GLOB reference");
155 }
156 else {
157 if (SvTYPE(sv) != SVt_PVGV) {
158 char *sym;
159 STRLEN len;
160
161 if (SvGMAGICAL(sv)) {
162 mg_get(sv);
163 if (SvROK(sv))
164 goto wasref;
165 }
166 if (!SvOK(sv) && sv != &PL_sv_undef) {
167 /* If this is a 'my' scalar and flag is set then vivify
168 * NI-S 1999/05/07
169 */
170 if (SvREADONLY(sv))
171 Perl_croak(aTHX_ PL_no_modify);
172 if (PL_op->op_private & OPpDEREF) {
173 GV *gv;
174 if (cUNOP->op_targ) {
175 STRLEN len;
176 SV *namesv = PAD_SV(cUNOP->op_targ);
177 const char *name = SvPV(namesv, len);
178 gv = (GV*)NEWSV(0,0);
179 gv_init(gv, CopSTASH(PL_curcop), name, len, 0);
180 }
181 else {
182 const char *name = CopSTASHPV(PL_curcop);
183 gv = newGVgen((char *)name);
184 }
185 if (SvTYPE(sv) < SVt_RV)
186 sv_upgrade(sv, SVt_RV);
187 if (SvPVX_const(sv)) {
188 SvPV_free(sv);
189 SvLEN_set(sv, 0);
190 SvCUR_set(sv, 0);
191 }
192 SvRV_set(sv, (SV*)gv);
193 SvROK_on(sv);
194 SvSETMAGIC(sv);
195 goto wasref;
196 }
197 if (PL_op->op_flags & OPf_REF ||
198 PL_op->op_private & HINT_STRICT_REFS)
199 DIE(aTHX_ PL_no_usym, "a symbol");
200 if (ckWARN(WARN_UNINITIALIZED))
201 report_uninit();
202 RETSETUNDEF;
203 }
204 sym = SvPV(sv,len);
205 if ((PL_op->op_flags & OPf_SPECIAL) &&
206 !(PL_op->op_flags & OPf_MOD))
207 {
208 sv = (SV*)gv_fetchpv(sym, FALSE, SVt_PVGV);
209 if (!sv
210 && (!is_gv_magical(sym,len,0)
211 || !(sv = (SV*)gv_fetchpv(sym, TRUE, SVt_PVGV))))
212 {
213 RETSETUNDEF;
214 }
215 }
216 else {
217 if (PL_op->op_private & HINT_STRICT_REFS)
218 DIE(aTHX_ PL_no_symref, sym, "a symbol");
219 sv = (SV*)gv_fetchpv(sym, TRUE, SVt_PVGV);
220 }
221 }
222 }
223 if (PL_op->op_private & OPpLVAL_INTRO)
224 save_gp((GV*)sv, !(PL_op->op_flags & OPf_SPECIAL));
225 SETs(sv);
226 RETURN;
227}
228
229PP(pp_rv2sv)
230{
231 GV *gv = Nullgv;
232 dSP; dTOPss;
233
234 if (SvROK(sv)) {
235 wasref:
236 tryAMAGICunDEREF(to_sv);
237
238 sv = SvRV(sv);
239 switch (SvTYPE(sv)) {
240 case SVt_PVAV:
241 case SVt_PVHV:
242 case SVt_PVCV:
243 DIE(aTHX_ "Not a SCALAR reference");
244 }
245 }
246 else {
247 char *sym;
248 STRLEN len;
249 gv = (GV*)sv;
250
251 if (SvTYPE(gv) != SVt_PVGV) {
252 if (SvGMAGICAL(sv)) {
253 mg_get(sv);
254 if (SvROK(sv))
255 goto wasref;
256 }
257 if (!SvOK(sv)) {
258 if (PL_op->op_flags & OPf_REF ||
259 PL_op->op_private & HINT_STRICT_REFS)
260 DIE(aTHX_ PL_no_usym, "a SCALAR");
261 if (ckWARN(WARN_UNINITIALIZED))
262 report_uninit();
263 RETSETUNDEF;
264 }
265 sym = SvPV(sv, len);
266 if ((PL_op->op_flags & OPf_SPECIAL) &&
267 !(PL_op->op_flags & OPf_MOD))
268 {
269 gv = (GV*)gv_fetchpv(sym, FALSE, SVt_PV);
270 if (!gv
271 && (!is_gv_magical(sym,len,0)
272 || !(gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PV))))
273 {
274 RETSETUNDEF;
275 }
276 }
277 else {
278 if (PL_op->op_private & HINT_STRICT_REFS)
279 DIE(aTHX_ PL_no_symref, sym, "a SCALAR");
280 gv = (GV*)gv_fetchpv(sym, TRUE, SVt_PV);
281 }
282 }
283 sv = GvSVn(gv);
284 }
285 if (PL_op->op_flags & OPf_MOD) {
286 if (PL_op->op_private & OPpLVAL_INTRO) {
287 if (cUNOP->op_first->op_type == OP_NULL)
288 sv = save_scalar((GV*)TOPs);
289 else if (gv)
290 sv = save_scalar(gv);
291 else
292 Perl_croak(aTHX_ PL_no_localize_ref);
293 }
294 else if (PL_op->op_private & OPpDEREF)
295 vivify_ref(sv, PL_op->op_private & OPpDEREF);
296 }
297 SETs(sv);
298 RETURN;
299}
300
301PP(pp_av2arylen)
302{
303 dSP;
304 AV *const av = (AV*)TOPs;
305 SV *sv = AvARYLEN(av);
306 if (!sv) {
307 AvARYLEN(av) = sv = NEWSV(0,0);
308 sv_upgrade(sv, SVt_IV);
309 sv_magic(sv, (SV*)av, PERL_MAGIC_arylen, Nullch, 0);
310 }
311 SETs(sv);
312 RETURN;
313}
314
315PP(pp_pos)
316{
317 dSP; dTARGET; dPOPss;
318
319 if (PL_op->op_flags & OPf_MOD || LVRET) {
320 if (SvTYPE(TARG) < SVt_PVLV) {
321 sv_upgrade(TARG, SVt_PVLV);
322 sv_magic(TARG, Nullsv, PERL_MAGIC_pos, Nullch, 0);
323 }
324
325 LvTYPE(TARG) = '.';
326 if (LvTARG(TARG) != sv) {
327 if (LvTARG(TARG))
328 SvREFCNT_dec(LvTARG(TARG));
329 LvTARG(TARG) = SvREFCNT_inc(sv);
330 }
331 PUSHs(TARG); /* no SvSETMAGIC */
332 RETURN;
333 }
334 else {
335 if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
336 const MAGIC * const mg = mg_find(sv, PERL_MAGIC_regex_global);
337 if (mg && mg->mg_len >= 0) {
338 I32 i = mg->mg_len;
339 if (DO_UTF8(sv))
340 sv_pos_b2u(sv, &i);
341 PUSHi(i + PL_curcop->cop_arybase);
342 RETURN;
343 }
344 }
345 RETPUSHUNDEF;
346 }
347}
348
349PP(pp_rv2cv)
350{
351 dSP;
352 GV *gv;
353 HV *stash;
354
355 /* We usually try to add a non-existent subroutine in case of AUTOLOAD. */
356 /* (But not in defined().) */
357 CV *cv = sv_2cv(TOPs, &stash, &gv, !(PL_op->op_flags & OPf_SPECIAL));
358 if (cv) {
359 if (CvCLONE(cv))
360 cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
361 if ((PL_op->op_private & OPpLVAL_INTRO)) {
362 if (gv && GvCV(gv) == cv && (gv = gv_autoload4(GvSTASH(gv), GvNAME(gv), GvNAMELEN(gv), FALSE)))
363 cv = GvCV(gv);
364 if (!CvLVALUE(cv))
365 DIE(aTHX_ "Can't modify non-lvalue subroutine call");
366 }
367 }
368 else
369 cv = (CV*)&PL_sv_undef;
370 SETs((SV*)cv);
371 RETURN;
372}
373
374PP(pp_prototype)
375{
376 dSP;
377 CV *cv;
378 HV *stash;
379 GV *gv;
380 SV *ret;
381
382 ret = &PL_sv_undef;
383 if (SvPOK(TOPs) && SvCUR(TOPs) >= 7) {
384 const char *s = SvPVX_const(TOPs);
385 if (strnEQ(s, "CORE::", 6)) {
386 const int code = keyword((char *)s + 6, SvCUR(TOPs) - 6);
387 if (code < 0) { /* Overridable. */
388#define MAX_ARGS_OP ((sizeof(I32) - 1) * 2)
389 int i = 0, n = 0, seen_question = 0;
390 I32 oa;
391 char str[ MAX_ARGS_OP * 2 + 2 ]; /* One ';', one '\0' */
392
393 if (code == -KEY_chop || code == -KEY_chomp
394 || code == -KEY_exec || code == -KEY_system)
395 goto set;
396 while (i < MAXO) { /* The slow way. */
397 if (strEQ(s + 6, PL_op_name[i])
398 || strEQ(s + 6, PL_op_desc[i]))
399 {
400 goto found;
401 }
402 i++;
403 }
404 goto nonesuch; /* Should not happen... */
405 found:
406 oa = PL_opargs[i] >> OASHIFT;
407 while (oa) {
408 if (oa & OA_OPTIONAL && !seen_question) {
409 seen_question = 1;
410 str[n++] = ';';
411 }
412 if ((oa & (OA_OPTIONAL - 1)) >= OA_AVREF
413 && (oa & (OA_OPTIONAL - 1)) <= OA_SCALARREF
414 /* But globs are already references (kinda) */
415 && (oa & (OA_OPTIONAL - 1)) != OA_FILEREF
416 ) {
417 str[n++] = '\\';
418 }
419 str[n++] = ("?$@@%&*$")[oa & (OA_OPTIONAL - 1)];
420 oa = oa >> 4;
421 }
422 str[n++] = '\0';
423 ret = sv_2mortal(newSVpvn(str, n - 1));
424 }
425 else if (code) /* Non-Overridable */
426 goto set;
427 else { /* None such */
428 nonesuch:
429 DIE(aTHX_ "Can't find an opnumber for \"%s\"", s+6);
430 }
431 }
432 }
433 cv = sv_2cv(TOPs, &stash, &gv, FALSE);
434 if (cv && SvPOK(cv))
435 ret = sv_2mortal(newSVpvn(SvPVX_const(cv), SvCUR(cv)));
436 set:
437 SETs(ret);
438 RETURN;
439}
440
441PP(pp_anoncode)
442{
443 dSP;
444 CV* cv = (CV*)PAD_SV(PL_op->op_targ);
445 if (CvCLONE(cv))
446 cv = (CV*)sv_2mortal((SV*)cv_clone(cv));
447 EXTEND(SP,1);
448 PUSHs((SV*)cv);
449 RETURN;
450}
451
452PP(pp_srefgen)
453{
454 dSP;
455 *SP = refto(*SP);
456 RETURN;
457}
458
459PP(pp_refgen)
460{
461 dSP; dMARK;
462 if (GIMME != G_ARRAY) {
463 if (++MARK <= SP)
464 *MARK = *SP;
465 else
466 *MARK = &PL_sv_undef;
467 *MARK = refto(*MARK);
468 SP = MARK;
469 RETURN;
470 }
471 EXTEND_MORTAL(SP - MARK);
472 while (++MARK <= SP)
473 *MARK = refto(*MARK);
474 RETURN;
475}
476
477STATIC SV*
478S_refto(pTHX_ SV *sv)
479{
480 SV* rv;
481
482 if (SvTYPE(sv) == SVt_PVLV && LvTYPE(sv) == 'y') {
483 if (LvTARGLEN(sv))
484 vivify_defelem(sv);
485 if (!(sv = LvTARG(sv)))
486 sv = &PL_sv_undef;
487 else
488 (void)SvREFCNT_inc(sv);
489 }
490 else if (SvTYPE(sv) == SVt_PVAV) {
491 if (!AvREAL((AV*)sv) && AvREIFY((AV*)sv))
492 av_reify((AV*)sv);
493 SvTEMP_off(sv);
494 (void)SvREFCNT_inc(sv);
495 }
496 else if (SvPADTMP(sv) && !IS_PADGV(sv))
497 sv = newSVsv(sv);
498 else {
499 SvTEMP_off(sv);
500 (void)SvREFCNT_inc(sv);
501 }
502 rv = sv_newmortal();
503 sv_upgrade(rv, SVt_RV);
504 SvRV_set(rv, sv);
505 SvROK_on(rv);
506 return rv;
507}
508
509PP(pp_ref)
510{
511 dSP; dTARGET;
512 const char *pv;
513 SV * const sv = POPs;
514
515 if (sv && SvGMAGICAL(sv))
516 mg_get(sv);
517
518 if (!sv || !SvROK(sv))
519 RETPUSHNO;
520
521 pv = sv_reftype(SvRV(sv),TRUE);
522 PUSHp(pv, strlen(pv));
523 RETURN;
524}
525
526PP(pp_bless)
527{
528 dSP;
529 HV *stash;
530
531 if (MAXARG == 1)
532 stash = CopSTASH(PL_curcop);
533 else {
534 SV * const ssv = POPs;
535 STRLEN len;
536 const char *ptr;
537
538 if (ssv && !SvGMAGICAL(ssv) && !SvAMAGIC(ssv) && SvROK(ssv))
539 Perl_croak(aTHX_ "Attempt to bless into a reference");
540 ptr = SvPV_const(ssv,len);
541 if (len == 0 && ckWARN(WARN_MISC))
542 Perl_warner(aTHX_ packWARN(WARN_MISC),
543 "Explicit blessing to '' (assuming package main)");
544 stash = gv_stashpvn(ptr, len, TRUE);
545 }
546
547 (void)sv_bless(TOPs, stash);
548 RETURN;
549}
550
551PP(pp_gelem)
552{
553 dSP;
554
555 SV *sv = POPs;
556 const char * const elem = SvPV_nolen_const(sv);
557 GV * const gv = (GV*)POPs;
558 SV * tmpRef = Nullsv;
559
560 sv = Nullsv;
561 if (elem) {
562 /* elem will always be NUL terminated. */
563 const char * const second_letter = elem + 1;
564 switch (*elem) {
565 case 'A':
566 if (strEQ(second_letter, "RRAY"))
567 tmpRef = (SV*)GvAV(gv);
568 break;
569 case 'C':
570 if (strEQ(second_letter, "ODE"))
571 tmpRef = (SV*)GvCVu(gv);
572 break;
573 case 'F':
574 if (strEQ(second_letter, "ILEHANDLE")) {
575 /* finally deprecated in 5.8.0 */
576 deprecate("*glob{FILEHANDLE}");
577 tmpRef = (SV*)GvIOp(gv);
578 }
579 else
580 if (strEQ(second_letter, "ORMAT"))
581 tmpRef = (SV*)GvFORM(gv);
582 break;
583 case 'G':
584 if (strEQ(second_letter, "LOB"))
585 tmpRef = (SV*)gv;
586 break;
587 case 'H':
588 if (strEQ(second_letter, "ASH"))
589 tmpRef = (SV*)GvHV(gv);
590 break;
591 case 'I':
592 if (*second_letter == 'O' && !elem[2])
593 tmpRef = (SV*)GvIOp(gv);
594 break;
595 case 'N':
596 if (strEQ(second_letter, "AME"))
597 sv = newSVpvn(GvNAME(gv), GvNAMELEN(gv));
598 break;
599 case 'P':
600 if (strEQ(second_letter, "ACKAGE")) {
601 const char *name = HvNAME_get(GvSTASH(gv));
602 sv = newSVpv(name ? name : "__ANON__", 0);
603 }
604 break;
605 case 'S':
606 if (strEQ(second_letter, "CALAR"))
607 tmpRef = GvSV(gv);
608 break;
609 }
610 }
611 if (tmpRef)
612 sv = newRV(tmpRef);
613 if (sv)
614 sv_2mortal(sv);
615 else
616 sv = &PL_sv_undef;
617 XPUSHs(sv);
618 RETURN;
619}
620
621/* Pattern matching */
622
623PP(pp_study)
624{
625 dSP; dPOPss;
626 register unsigned char *s;
627 register I32 pos;
628 register I32 ch;
629 register I32 *sfirst;
630 register I32 *snext;
631 STRLEN len;
632
633 if (sv == PL_lastscream) {
634 if (SvSCREAM(sv))
635 RETPUSHYES;
636 }
637 else {
638 if (PL_lastscream) {
639 SvSCREAM_off(PL_lastscream);
640 SvREFCNT_dec(PL_lastscream);
641 }
642 PL_lastscream = SvREFCNT_inc(sv);
643 }
644
645 s = (unsigned char*)(SvPV(sv, len));
646 pos = len;
647 if (pos <= 0)
648 RETPUSHNO;
649 if (pos > PL_maxscream) {
650 if (PL_maxscream < 0) {
651 PL_maxscream = pos + 80;
652 Newx(PL_screamfirst, 256, I32);
653 Newx(PL_screamnext, PL_maxscream, I32);
654 }
655 else {
656 PL_maxscream = pos + pos / 4;
657 Renew(PL_screamnext, PL_maxscream, I32);
658 }
659 }
660
661 sfirst = PL_screamfirst;
662 snext = PL_screamnext;
663
664 if (!sfirst || !snext)
665 DIE(aTHX_ "do_study: out of memory");
666
667 for (ch = 256; ch; --ch)
668 *sfirst++ = -1;
669 sfirst -= 256;
670
671 while (--pos >= 0) {
672 register const I32 ch = s[pos];
673 if (sfirst[ch] >= 0)
674 snext[pos] = sfirst[ch] - pos;
675 else
676 snext[pos] = -pos;
677 sfirst[ch] = pos;
678 }
679
680 SvSCREAM_on(sv);
681 /* piggyback on m//g magic */
682 sv_magic(sv, Nullsv, PERL_MAGIC_regex_global, Nullch, 0);
683 RETPUSHYES;
684}
685
686PP(pp_trans)
687{
688 dSP; dTARG;
689 SV *sv;
690
691 if (PL_op->op_flags & OPf_STACKED)
692 sv = POPs;
693 else {
694 sv = DEFSV;
695 EXTEND(SP,1);
696 }
697 TARG = sv_newmortal();
698 PUSHi(do_trans(sv));
699 RETURN;
700}
701
702/* Lvalue operators. */
703
704PP(pp_schop)
705{
706 dSP; dTARGET;
707 do_chop(TARG, TOPs);
708 SETTARG;
709 RETURN;
710}
711
712PP(pp_chop)
713{
714 dSP; dMARK; dTARGET; dORIGMARK;
715 while (MARK < SP)
716 do_chop(TARG, *++MARK);
717 SP = ORIGMARK;
718 XPUSHTARG;
719 RETURN;
720}
721
722PP(pp_schomp)
723{
724 dSP; dTARGET;
725 SETi(do_chomp(TOPs));
726 RETURN;
727}
728
729PP(pp_chomp)
730{
731 dSP; dMARK; dTARGET;
732 register I32 count = 0;
733
734 while (SP > MARK)
735 count += do_chomp(POPs);
736 XPUSHi(count);
737 RETURN;
738}
739
740PP(pp_defined)
741{
742 dSP;
743 register SV* const sv = POPs;
744
745 if (!sv || !SvANY(sv))
746 RETPUSHNO;
747 switch (SvTYPE(sv)) {
748 case SVt_PVAV:
749 if (AvMAX(sv) >= 0 || SvGMAGICAL(sv)
750 || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
751 RETPUSHYES;
752 break;
753 case SVt_PVHV:
754 if (HvARRAY(sv) || SvGMAGICAL(sv)
755 || (SvRMAGICAL(sv) && mg_find(sv, PERL_MAGIC_tied)))
756 RETPUSHYES;
757 break;
758 case SVt_PVCV:
759 if (CvROOT(sv) || CvXSUB(sv))