This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Eliminate Alpha warnings
[perl5.git] / op.c
CommitLineData
a0d0e21e 1/* op.c
79072805 2 *
9607fc9c 3 * Copyright (c) 1991-1997, Larry Wall
79072805
LW		 4 *
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
7 *
a0d0e21e
LW		 8 */
9
10/*
11 * "You see: Mr. Drogo, he married poor Miss Primula Brandybuck. She was
12 * our Mr. Bilbo's first cousin on the mother's side (her mother being the
13 * youngest of the Old Took's daughters); and Mr. Drogo was his second
14 * cousin. So Mr. Frodo is his first *and* second cousin, once removed
15 * either way, as the saying is, if you follow me." --the Gaffer
79072805
LW		 16 */
17
18#include "EXTERN.h"
19#include "perl.h"
20
c07a80fd 21#define USE_OP_MASK /* Turned on by default in 5.002beta1h */
22
e50aee73
AD		 23#ifdef USE_OP_MASK
24/*
25 * In the following definition, the ", (OP *) op" is just to make the compiler
a5f75d66 26 * think the expression is of the right type: croak actually does a Siglongjmp.
e50aee73 27 */
c07a80fd 28#define CHECKOP(type,op) \
28757baa 29 ((op_mask && op_mask[type]) \
30 ? ( op_free((OP*)op), \
31 croak("%s trapped by operation mask", op_desc[type]), \
32 Nullop ) \
c07a80fd 33 : (*check[type])((OP*)op))
e50aee73
AD		 34#else
35#define CHECKOP(type,op) (*check[type])(op)
36#endif /* USE_OP_MASK */
37
a0d0e21e 38static I32 list_assignment _((OP *op));
4633a7c4 39static OP *bad_type _((I32 n, char *t, char *name, OP *kid));
a0d0e21e
LW		 40static OP *modkids _((OP *op, I32 type));
41static OP *no_fh_allowed _((OP *op));
3fe9a6f1 42static bool scalar_mod_type _((OP *op, I32 type));
a0d0e21e 43static OP *scalarboolean _((OP *op));
4633a7c4
LW		 44static OP *too_few_arguments _((OP *op, char* name));
45static OP *too_many_arguments _((OP *op, char* name));
a0d0e21e 46static void null _((OP* op));
bbce6d69 47static PADOFFSET pad_findlex _((char* name, PADOFFSET newoff, U32 seq,
748a9306 48 CV* startcv, I32 cx_ix));
79072805 49
4633a7c4 50static char*
46fc3d4c 51gv_ename(gv)
52GV* gv;
4633a7c4
LW		 53{
54 SV* tmpsv = sv_newmortal();
46fc3d4c 55 gv_efullname3(tmpsv, gv, Nullch);
4633a7c4
LW		 56 return SvPV(tmpsv,na);
57}
58
8990e307 59static OP *
79072805
LW		 60no_fh_allowed(op)
61OP *op;
62{
46fc3d4c 63 yyerror(form("Missing comma after first argument to %s function",
64 op_desc[op->op_type]));
79072805
LW		 65 return op;
66}
67
8990e307 68static OP *
4633a7c4
LW		 69too_few_arguments(op, name)
70OP* op;
71char* name;
79072805 72{
46fc3d4c 73 yyerror(form("Not enough arguments for %s", name));
79072805
LW		 74 return op;
75}
76
8990e307 77static OP *
4633a7c4 78too_many_arguments(op, name)
79072805 79OP *op;
4633a7c4 80char* name;
79072805 81{
46fc3d4c 82 yyerror(form("Too many arguments for %s", name));
79072805
LW		 83 return op;
84}
85
8990e307 86static OP *
4633a7c4 87bad_type(n, t, name, kid)
8990e307
LW		 88I32 n;
89char *t;
4633a7c4 90char *name;
8990e307
LW		 91OP *kid;
92{
46fc3d4c 93 yyerror(form("Type of arg %d to %s must be %s (not %s)",
94 (int)n, name, t, op_desc[kid->op_type]));
8990e307
LW		 95 return op;
96}
97
a0d0e21e
LW		 98void
99assertref(op)
100OP *op;
101{
102 int type = op->op_type;
103 if (type != OP_AELEM && type != OP_HELEM) {
46fc3d4c 104 yyerror(form("Can't use subscript on %s", op_desc[type]));
8ebc5c01 105 if (type == OP_ENTERSUB || type == OP_RV2HV || type == OP_PADHV)
748a9306 106 warn("(Did you mean $ or @ instead of %c?)\n",
8ebc5c01 107 type == OP_ENTERSUB ? '&' : '%');
a0d0e21e
LW		 108 }
109}
110
79072805
LW		 111/* "register" allocation */
112
113PADOFFSET
93a17b20
LW		 114pad_allocmy(name)
115char *name;
116{
a0d0e21e
LW		 117 PADOFFSET off;
118 SV *sv;
119
120 if (!(isALPHA(name[1]) || name[1] == '_' && (int)strlen(name) > 2)) {
46fc3d4c 121 if (!isPRINT(name[1])) {
122 name[3] = '\0';
123 name[2] = toCTRL(name[1]);
124 name[1] = '^';
125 }
a0d0e21e
LW		 126 croak("Can't use global %s in \"my\"",name);
127 }
b1cb66bf 128 if (AvFILL(comppad_name) >= 0) {
129 SV **svp = AvARRAY(comppad_name);
130 for (off = AvFILL(comppad_name); off > comppad_name_floor; off--) {
131 if ((sv = svp[off])
132 && sv != &sv_undef
133 && SvIVX(sv) == 999999999 /* var is in open scope */
134 && strEQ(name, SvPVX(sv)))
135 {
136 warn("\"my\" variable %s masks earlier declaration in same scope", name);
137 break;
138 }
139 }
140 }
a0d0e21e
LW		 141 off = pad_alloc(OP_PADSV, SVs_PADMY);
142 sv = NEWSV(1102,0);
93a17b20
LW		 143 sv_upgrade(sv, SVt_PVNV);
144 sv_setpv(sv, name);
8990e307 145 av_store(comppad_name, off, sv);
748a9306 146 SvNVX(sv) = (double)999999999;
8990e307
LW		 147 SvIVX(sv) = 0; /* Not yet introduced--see newSTATEOP */
148 if (!min_intro_pending)
149 min_intro_pending = off;
150 max_intro_pending = off;
93a17b20 151 if (*name == '@')
463ee0b2 152 av_store(comppad, off, (SV*)newAV());
93a17b20 153 else if (*name == '%')
463ee0b2 154 av_store(comppad, off, (SV*)newHV());
ed6116ce 155 SvPADMY_on(curpad[off]);
93a17b20
LW		 156 return off;
157}
158
748a9306 159static PADOFFSET
e9a444f0 160#ifndef CAN_PROTOTYPE
748a9306 161pad_findlex(name, newoff, seq, startcv, cx_ix)
93a17b20 162char *name;
748a9306 163PADOFFSET newoff;
bbce6d69 164U32 seq;
748a9306
LW		 165CV* startcv;
166I32 cx_ix;
e9a444f0 167#else
bbce6d69 168pad_findlex(char *name, PADOFFSET newoff, U32 seq, CV* startcv, I32 cx_ix)
e9a444f0 169#endif
93a17b20 170{
748a9306 171 CV *cv;
93a17b20
LW		 172 I32 off;
173 SV *sv;
93a17b20
LW		 174 register I32 i;
175 register CONTEXT *cx;
a0d0e21e 176 int saweval;
93a17b20 177
748a9306 178 for (cv = startcv; cv; cv = CvOUTSIDE(cv)) {
4fdae800 179 AV *curlist = CvPADLIST(cv);
180 SV **svp = av_fetch(curlist, 0, FALSE);
748a9306 181 AV *curname;
4fdae800 182
748a9306 183 if (!svp || *svp == &sv_undef)
4633a7c4 184 continue;
748a9306
LW		 185 curname = (AV*)*svp;
186 svp = AvARRAY(curname);
187 for (off = AvFILL(curname); off > 0; off--) {
188 if ((sv = svp[off]) &&
189 sv != &sv_undef &&
190 seq <= SvIVX(sv) &&
13826f2c 191 seq > I_32(SvNVX(sv)) &&
748a9306
LW		 192 strEQ(SvPVX(sv), name))
193 {
5f05dabc 194 I32 depth;
195 AV *oldpad;
196 SV *oldsv;
197
198 depth = CvDEPTH(cv);
199 if (!depth) {
9607fc9c 200 if (newoff) {
201 if (SvFAKE(sv))
202 continue;
4fdae800 203 return 0; /* don't clone from inactive stack frame */
9607fc9c 204 }
5f05dabc 205 depth = 1;
206 }
207 oldpad = (AV*)*av_fetch(curlist, depth, FALSE);
208 oldsv = *av_fetch(oldpad, off, TRUE);
748a9306 209 if (!newoff) { /* Not a mere clone operation. */
9607fc9c 210 SV *namesv = NEWSV(1103,0);
748a9306 211 newoff = pad_alloc(OP_PADSV, SVs_PADMY);
9607fc9c 212 sv_upgrade(namesv, SVt_PVNV);
213 sv_setpv(namesv, name);
214 av_store(comppad_name, newoff, namesv);
215 SvNVX(namesv) = (double)curcop->cop_seq;
216 SvIVX(namesv) = 999999999; /* A ref, intro immediately */
217 SvFAKE_on(namesv); /* A ref, not a real var */
774d564b 218 if (CvANON(compcv) || SvTYPE(compcv) == SVt_PVFM) {
28757baa 219 /* "It's closures all the way down." */
220 CvCLONE_on(compcv);
54310121 221 if (cv == startcv) {
222 if (CvANON(compcv))
223 oldsv = Nullsv; /* no need to keep ref */
224 }
225 else {
28757baa 226 CV *bcv;
227 for (bcv = startcv;
228 bcv && bcv != cv && !CvCLONE(bcv);
229 bcv = CvOUTSIDE(bcv)) {
230 if (CvANON(bcv))
231 CvCLONE_on(bcv);
232 else {
774d564b 233 if (dowarn && !CvUNIQUE(cv))
44a8e56a 234 warn(
235 "Variable \"%s\" may be unavailable",
28757baa 236 name);
237 break;
238 }
239 }
240 }
241 }
44a8e56a 242 else if (!CvUNIQUE(compcv)) {
9607fc9c 243 if (dowarn && !SvFAKE(sv) && !CvUNIQUE(cv))
44a8e56a 244 warn("Variable \"%s\" will not stay shared", name);
5f05dabc 245 }
748a9306
LW		 246 }
247 av_store(comppad, newoff, SvREFCNT_inc(oldsv));
748a9306
LW		 248 return newoff;
249 }
93a17b20
LW		 250 }
251 }
252
253 /* Nothing in current lexical context--try eval's context, if any.
254 * This is necessary to let the perldb get at lexically scoped variables.
255 * XXX This will also probably interact badly with eval tree caching.
256 */
257
a0d0e21e 258 saweval = 0;
748a9306 259 for (i = cx_ix; i >= 0; i--) {
93a17b20
LW		 260 cx = &cxstack[i];
261 switch (cx->cx_type) {
262 default:
748a9306
LW		 263 if (i == 0 && saweval) {
264 seq = cxstack[saweval].blk_oldcop->cop_seq;
265 return pad_findlex(name, newoff, seq, main_cv, 0);
266 }
93a17b20
LW		 267 break;
268 case CXt_EVAL:
44a8e56a 269 switch (cx->blk_eval.old_op_type) {
270 case OP_ENTEREVAL:
271 saweval = i;
272 break;
273 case OP_REQUIRE:
274 /* require must have its own scope */
275 return 0;
276 }
93a17b20
LW		 277 break;
278 case CXt_SUB:
279 if (!saweval)
280 return 0;
281 cv = cx->blk_sub.cv;
748a9306
LW		 282 if (debstash && CvSTASH(cv) == debstash) { /* ignore DB'* scope */
283 saweval = i; /* so we know where we were called from */
93a17b20 284 continue;
93a17b20 285 }
748a9306
LW		 286 seq = cxstack[saweval].blk_oldcop->cop_seq;
287 return pad_findlex(name, newoff, seq, cv, i-1);
93a17b20
LW		 288 }
289 }
290
748a9306
LW		 291 return 0;
292}
a0d0e21e 293
748a9306
LW		 294PADOFFSET
295pad_findmy(name)
296char *name;
297{
298 I32 off;
54310121 299 I32 pendoff = 0;
748a9306
LW		 300 SV *sv;
301 SV **svp = AvARRAY(comppad_name);
bbce6d69 302 U32 seq = cop_seqmax;
748a9306
LW		 303
304 /* The one we're looking for is probably just before comppad_name_fill. */
4633a7c4 305 for (off = AvFILL(comppad_name); off > 0; off--) {
a0d0e21e
LW		 306 if ((sv = svp[off]) &&
307 sv != &sv_undef &&
54310121 308 (!SvIVX(sv) ||
309 (seq <= SvIVX(sv) &&
310 seq > I_32(SvNVX(sv)))) &&
a0d0e21e
LW		 311 strEQ(SvPVX(sv), name))
312 {
54310121 313 if (SvIVX(sv))
314 return (PADOFFSET)off;
315 pendoff = off; /* this pending def. will override import */
a0d0e21e
LW		 316 }
317 }
748a9306
LW		 318
319 /* See if it's in a nested scope */
320 off = pad_findlex(name, 0, seq, CvOUTSIDE(compcv), cxstack_ix);
54310121 321 if (off) {
322 /* If there is a pending local definition, this new alias must die */
323 if (pendoff)
324 SvIVX(AvARRAY(comppad_name)[off]) = seq;
748a9306 325 return off;
54310121 326 }
748a9306 327
93a17b20
LW		 328 return 0;
329}
330
331void
332pad_leavemy(fill)
333I32 fill;
334{
335 I32 off;
8990e307 336 SV **svp = AvARRAY(comppad_name);
93a17b20 337 SV *sv;
8990e307
LW		 338 if (min_intro_pending && fill < min_intro_pending) {
339 for (off = max_intro_pending; off >= min_intro_pending; off--) {
a0d0e21e 340 if ((sv = svp[off]) && sv != &sv_undef)
8990e307
LW		 341 warn("%s never introduced", SvPVX(sv));
342 }
343 }
344 /* "Deintroduce" my variables that are leaving with this scope. */
345 for (off = AvFILL(comppad_name); off > fill; off--) {
748a9306 346 if ((sv = svp[off]) && sv != &sv_undef && SvIVX(sv) == 999999999)
463ee0b2 347 SvIVX(sv) = cop_seqmax;
93a17b20
LW		 348 }
349}
350
351PADOFFSET
79072805
LW		 352pad_alloc(optype,tmptype)
353I32 optype;
ed6116ce 354U32 tmptype;
79072805
LW		 355{
356 SV *sv;
357 I32 retval;
358
359 if (AvARRAY(comppad) != curpad)
463ee0b2 360 croak("panic: pad_alloc");
a0d0e21e
LW		 361 if (pad_reset_pending)
362 pad_reset();
ed6116ce 363 if (tmptype & SVs_PADMY) {
79072805
LW		 364 do {
365 sv = *av_fetch(comppad, AvFILL(comppad) + 1, TRUE);
ed6116ce 366 } while (SvPADBUSY(sv)); /* need a fresh one */
79072805
LW		 367 retval = AvFILL(comppad);
368 }
369 else {
bbce6d69 370 SV **names = AvARRAY(comppad_name);
371 SSize_t names_fill = AvFILL(comppad_name);
372 for (;;) {
373 /*
374 * "foreach" index vars temporarily become aliases to non-"my"
375 * values. Thus we must skip, not just pad values that are
376 * marked as current pad values, but also those with names.
377 */
378 if (++padix <= names_fill &&
379 (sv = names[padix]) && sv != &sv_undef)
380 continue;
381 sv = *av_fetch(comppad, padix, TRUE);
382 if (!(SvFLAGS(sv) & (SVs_PADTMP|SVs_PADMY)))
383 break;
384 }
79072805
LW		 385 retval = padix;
386 }
8990e307 387 SvFLAGS(sv) |= tmptype;
79072805 388 curpad = AvARRAY(comppad);
760ac839 389 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad alloc %ld for %s\n", (long) retval, op_name[optype]));
79072805
LW		 390 return (PADOFFSET)retval;
391}
392
393SV *
a0d0e21e 394#ifndef CAN_PROTOTYPE
79072805
LW		 395pad_sv(po)
396PADOFFSET po;
8990e307
LW		 397#else
398pad_sv(PADOFFSET po)
a0d0e21e 399#endif /* CAN_PROTOTYPE */
79072805
LW		 400{
401 if (!po)
463ee0b2 402 croak("panic: pad_sv po");
68dc0745 403 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad sv %lu\n", (unsigned long)po));
79072805
LW		 404 return curpad[po]; /* eventually we'll turn this into a macro */
405}
406
407void
a0d0e21e 408#ifndef CAN_PROTOTYPE
79072805
LW		 409pad_free(po)
410PADOFFSET po;
8990e307
LW		 411#else
412pad_free(PADOFFSET po)
a0d0e21e 413#endif /* CAN_PROTOTYPE */
79072805 414{
a0d0e21e
LW		 415 if (!curpad)
416 return;
79072805 417 if (AvARRAY(comppad) != curpad)
463ee0b2 418 croak("panic: pad_free curpad");
79072805 419 if (!po)
463ee0b2 420 croak("panic: pad_free po");
68dc0745 421 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad free %lu\n", (unsigned long)po));
ff0cee69 422 if (curpad[po] && !SvIMMORTAL(curpad[po]))
ed6116ce 423 SvPADTMP_off(curpad[po]);
a0d0e21e 424 if ((I32)po < padix)
79072805
LW		 425 padix = po - 1;
426}
427
428void
a0d0e21e 429#ifndef CAN_PROTOTYPE
79072805
LW		 430pad_swipe(po)
431PADOFFSET po;
8990e307
LW		 432#else
433pad_swipe(PADOFFSET po)
a0d0e21e 434#endif /* CAN_PROTOTYPE */
79072805
LW		 435{
436 if (AvARRAY(comppad) != curpad)
463ee0b2 437 croak("panic: pad_swipe curpad");
79072805 438 if (!po)
463ee0b2 439 croak("panic: pad_swipe po");
68dc0745 440 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad swipe %lu\n", (unsigned long)po));
ed6116ce 441 SvPADTMP_off(curpad[po]);
a0d0e21e
LW		 442 curpad[po] = NEWSV(1107,0);
443 SvPADTMP_on(curpad[po]);
444 if ((I32)po < padix)
79072805
LW		 445 padix = po - 1;
446}
447
448void
449pad_reset()
450{
451 register I32 po;
452
453 if (AvARRAY(comppad) != curpad)
463ee0b2 454 croak("panic: pad_reset curpad");
760ac839 455 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad reset\n"));
748a9306
LW		 456 if (!tainting) { /* Can't mix tainted and non-tainted temporaries. */
457 for (po = AvMAX(comppad); po > padix_floor; po--) {
ff0cee69 458 if (curpad[po] && !SvIMMORTAL(curpad[po]))
748a9306
LW		 459 SvPADTMP_off(curpad[po]);
460 }
461 padix = padix_floor;
79072805 462 }
a0d0e21e 463 pad_reset_pending = FALSE;
79072805
LW		 464}
465
466/* Destructor */
467
468void
469op_free(op)
470OP *op;
471{
85e6fe83 472 register OP *kid, *nextkid;
79072805 473
b1cb66bf 474 if (!op || op->op_seq == (U16)-1)
79072805
LW		 475 return;
476
477 if (op->op_flags & OPf_KIDS) {
85e6fe83
LW		 478 for (kid = cUNOP->op_first; kid; kid = nextkid) {
479 nextkid = kid->op_sibling; /* Get before next freeing kid */
79072805 480 op_free(kid);
85e6fe83 481 }
79072805
LW		 482 }
483
79072805 484 switch (op->op_type) {
8990e307
LW		 485 case OP_NULL:
486 op->op_targ = 0; /* Was holding old type, if any. */
487 break;
a0d0e21e
LW		 488 case OP_ENTEREVAL:
489 op->op_targ = 0; /* Was holding hints. */
490 break;
a6006777 491 default:
492 if (!(op->op_flags & OPf_REF) || (check[op->op_type] != ck_ftst))
493 break;
494 /* FALL THROUGH */
463ee0b2 495 case OP_GVSV:
79072805 496 case OP_GV:
a6006777 497 case OP_AELEMFAST:
a0d0e21e 498 SvREFCNT_dec(cGVOP->op_gv);
8990e307
LW		 499 break;
500 case OP_NEXTSTATE:
501 case OP_DBSTATE:
5f05dabc 502 Safefree(cCOP->cop_label);
8990e307 503 SvREFCNT_dec(cCOP->cop_filegv);
79072805
LW		 504 break;
505 case OP_CONST:
8990e307 506 SvREFCNT_dec(cSVOP->op_sv);
79072805 507 break;
748a9306
LW		 508 case OP_GOTO:
509 case OP_NEXT:
510 case OP_LAST:
511 case OP_REDO:
512 if (op->op_flags & (OPf_SPECIAL|OPf_STACKED|OPf_KIDS))
513 break;
514 /* FALL THROUGH */
a0d0e21e
LW		 515 case OP_TRANS:
516 Safefree(cPVOP->op_pv);
517 break;
518 case OP_SUBST:
519 op_free(cPMOP->op_pmreplroot);
520 /* FALL THROUGH */
748a9306 521 case OP_PUSHRE:
a0d0e21e 522 case OP_MATCH:
e50aee73 523 pregfree(cPMOP->op_pmregexp);
748a9306 524 SvREFCNT_dec(cPMOP->op_pmshort);
a0d0e21e 525 break;
79072805
LW		 526 }
527
8990e307
LW		 528 if (op->op_targ > 0)
529 pad_free(op->op_targ);
530
79072805
LW		 531 Safefree(op);
532}
533
8990e307
LW		 534static void
535null(op)
536OP* op;
537{
538 if (op->op_type != OP_NULL && op->op_targ > 0)
539 pad_free(op->op_targ);
540 op->op_targ = op->op_type;
541 op->op_type = OP_NULL;
542 op->op_ppaddr = ppaddr[OP_NULL];
543}
544
79072805
LW		 545/* Contextualizers */
546
463ee0b2 547#define LINKLIST(o) ((o)->op_next ? (o)->op_next : linklist((OP*)o))
79072805
LW		 548
549OP *
550linklist(op)
551OP *op;
552{
553 register OP *kid;
554
555 if (op->op_next)
556 return op->op_next;
557
558 /* establish postfix order */
559 if (cUNOP->op_first) {
560 op->op_next = LINKLIST(cUNOP->op_first);
561 for (kid = cUNOP->op_first; kid; kid = kid->op_sibling) {
562 if (kid->op_sibling)
563 kid->op_next = LINKLIST(kid->op_sibling);
564 else
565 kid->op_next = op;
566 }
567 }
568 else
569 op->op_next = op;
570
571 return op->op_next;
572}
573
574OP *
575scalarkids(op)
576OP *op;
577{
578 OP *kid;
579 if (op && op->op_flags & OPf_KIDS) {
580 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling)
581 scalar(kid);
582 }
583 return op;
584}
585
a0d0e21e 586static OP *
8990e307
LW		 587scalarboolean(op)
588OP *op;
589{
590 if (dowarn &&
a0d0e21e
LW		 591 op->op_type == OP_SASSIGN && cBINOP->op_first->op_type == OP_CONST) {
592 line_t oldline = curcop->cop_line;
593
594 if (copline != NOLINE)
595 curcop->cop_line = copline;
596 warn("Found = in conditional, should be ==");
597 curcop->cop_line = oldline;
598 }
8990e307
LW		 599 return scalar(op);
600}
601
602OP *
79072805
LW		 603scalar(op)
604OP *op;
605{
606 OP *kid;
607
a0d0e21e 608 /* assumes no premature commitment */
54310121 609 if (!op || (op->op_flags & OPf_WANT) || error_count
610 || op->op_type == OP_RETURN)
79072805
LW		 611 return op;
612
54310121 613 op->op_flags = (op->op_flags & ~OPf_WANT) | OPf_WANT_SCALAR;
79072805
LW		 614
615 switch (op->op_type) {
616 case OP_REPEAT:
4633a7c4
LW		 617 if (op->op_private & OPpREPEAT_DOLIST)
618 null(((LISTOP*)cBINOP->op_first)->op_first);
79072805 619 scalar(cBINOP->op_first);
8990e307 620 break;
79072805
LW		 621 case OP_OR:
622 case OP_AND:
623 case OP_COND_EXPR:
8990e307
LW		 624 for (kid = cUNOP->op_first->op_sibling; kid; kid = kid->op_sibling)
625 scalar(kid);
79072805 626 break;
a0d0e21e
LW		 627 case OP_SPLIT:
628 if ((kid = ((LISTOP*)op)->op_first) && kid->op_type == OP_PUSHRE) {
629 if (!kPMOP->op_pmreplroot)
630 deprecate("implicit split to @_");
631 }
632 /* FALL THROUGH */
79072805
LW		 633 case OP_MATCH:
634 case OP_SUBST:
635 case OP_NULL:
8990e307
LW		 636 default:
637 if (op->op_flags & OPf_KIDS) {
638 for (kid = cUNOP->op_first; kid; kid = kid->op_sibling)
639 scalar(kid);
640 }
79072805
LW		 641 break;
642 case OP_LEAVE:
643 case OP_LEAVETRY:
54310121 644 kid = cLISTOP->op_first;
645 scalar(kid);
646 while (kid = kid->op_sibling) {
647 if (kid->op_sibling)
648 scalarvoid(kid);
649 else
650 scalar(kid);
651 }
652 curcop = &compiling;
653 break;
748a9306 654 case OP_SCOPE:
79072805 655 case OP_LINESEQ:
8990e307 656 case OP_LIST:
79072805
LW		 657 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling) {
658 if (kid->op_sibling)
659 scalarvoid(kid);
660 else
661 scalar(kid);
662 }
93a17b20 663 curcop = &compiling;
79072805
LW		 664 break;
665 }
79072805
LW		 666 return op;
667}
668
669OP *
670scalarvoid(op)
671OP *op;
672{
673 OP *kid;
8990e307
LW		 674 char* useless = 0;
675 SV* sv;
79072805 676
54310121 677 /* assumes no premature commitment */
678 if (!op || (op->op_flags & OPf_WANT) == OPf_WANT_LIST || error_count
679 || op->op_type == OP_RETURN)
79072805
LW		 680 return op;
681
54310121 682 op->op_flags = (op->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
79072805
LW		 683
684 switch (op->op_type) {
685 default:
8990e307
LW		 686 if (!(opargs[op->op_type] & OA_FOLDCONST))
687 break;
36477c24 688 /* FALL THROUGH */
689 case OP_REPEAT:
8990e307
LW		 690 if (op->op_flags & OPf_STACKED)
691 break;
692 /* FALL THROUGH */
693 case OP_GVSV:
694 case OP_WANTARRAY:
695 case OP_GV:
696 case OP_PADSV:
697 case OP_PADAV:
698 case OP_PADHV:
699 case OP_PADANY:
700 case OP_AV2ARYLEN:
8990e307 701 case OP_REF:
a0d0e21e
LW		 702 case OP_REFGEN:
703 case OP_SREFGEN:
8990e307
LW		 704 case OP_DEFINED:
705 case OP_HEX:
706 case OP_OCT:
707 case OP_LENGTH:
708 case OP_SUBSTR:
709 case OP_VEC:
710 case OP_INDEX:
711 case OP_RINDEX:
712 case OP_SPRINTF:
713 case OP_AELEM:
714 case OP_AELEMFAST:
715 case OP_ASLICE:
8990e307
LW		 716 case OP_HELEM:
717 case OP_HSLICE:
718 case OP_UNPACK:
719 case OP_PACK:
8990e307
LW		 720 case OP_JOIN:
721 case OP_LSLICE:
722 case OP_ANONLIST:
723 case OP_ANONHASH:
724 case OP_SORT:
725 case OP_REVERSE:
726 case OP_RANGE:
727 case OP_FLIP:
728 case OP_FLOP:
729 case OP_CALLER:
730 case OP_FILENO:
731 case OP_EOF:
732 case OP_TELL:
733 case OP_GETSOCKNAME:
734 case OP_GETPEERNAME:
735 case OP_READLINK:
736 case OP_TELLDIR:
737 case OP_GETPPID:
738 case OP_GETPGRP:
739 case OP_GETPRIORITY:
740 case OP_TIME:
741 case OP_TMS:
742 case OP_LOCALTIME:
743 case OP_GMTIME:
744 case OP_GHBYNAME:
745 case OP_GHBYADDR:
746 case OP_GHOSTENT:
747 case OP_GNBYNAME:
748 case OP_GNBYADDR:
749 case OP_GNETENT:
750 case OP_GPBYNAME:
751 case OP_GPBYNUMBER:
752 case OP_GPROTOENT:
753 case OP_GSBYNAME:
754 case OP_GSBYPORT:
755 case OP_GSERVENT:
756 case OP_GPWNAM:
757 case OP_GPWUID:
758 case OP_GGRNAM:
759 case OP_GGRGID:
760 case OP_GETLOGIN:
a0d0e21e 761 if (!(op->op_private & OPpLVAL_INTRO))
c07a80fd 762 useless = op_desc[op->op_type];
8990e307
LW		 763 break;
764
765 case OP_RV2GV:
766 case OP_RV2SV:
767 case OP_RV2AV:
768 case OP_RV2HV:
a0d0e21e 769 if (!(op->op_private & OPpLVAL_INTRO) &&
85e6fe83 770 (!op->op_sibling || op->op_sibling->op_type != OP_READLINE))
8990e307
LW		 771 useless = "a variable";
772 break;
79072805 773
93a17b20 774 case OP_NEXTSTATE:
8990e307 775 case OP_DBSTATE:
748a9306 776 curcop = ((COP*)op); /* for warning below */
93a17b20
LW		 777 break;
778
79072805 779 case OP_CONST:
8990e307
LW		 780 sv = cSVOP->op_sv;
781 if (dowarn) {
782 useless = "a constant";
783 if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0))
784 useless = 0;
785 else if (SvPOK(sv)) {
786 if (strnEQ(SvPVX(sv), "di", 2) ||
a0d0e21e 787 strnEQ(SvPVX(sv), "ds", 2) ||
8990e307
LW		 788 strnEQ(SvPVX(sv), "ig", 2))
789 useless = 0;
790 }
791 }
792 null(op); /* don't execute a constant */
793 SvREFCNT_dec(sv); /* don't even remember it */
79072805
LW		 794 break;
795
796 case OP_POSTINC:
8990e307 797 op->op_type = OP_PREINC; /* pre-increment is faster */
79072805
LW		 798 op->op_ppaddr = ppaddr[OP_PREINC];
799 break;
800
801 case OP_POSTDEC:
8990e307 802 op->op_type = OP_PREDEC; /* pre-decrement is faster */
79072805
LW		 803 op->op_ppaddr = ppaddr[OP_PREDEC];
804 break;
805
79072805
LW		 806 case OP_OR:
807 case OP_AND:
808 case OP_COND_EXPR:
809 for (kid = cUNOP->op_first->op_sibling; kid; kid = kid->op_sibling)
810 scalarvoid(kid);
811 break;
5aabfad6 812
a0d0e21e 813 case OP_NULL:
748a9306
LW		 814 if (op->op_targ == OP_NEXTSTATE || op->op_targ == OP_DBSTATE)
815 curcop = ((COP*)op); /* for warning below */
a0d0e21e
LW		 816 if (op->op_flags & OPf_STACKED)
817 break;
5aabfad6 818 /* FALL THROUGH */
79072805
LW		 819 case OP_ENTERTRY:
820 case OP_ENTER:
821 case OP_SCALAR:
79072805
LW		 822 if (!(op->op_flags & OPf_KIDS))
823 break;
54310121 824 /* FALL THROUGH */
463ee0b2 825 case OP_SCOPE:
79072805
LW		 826 case OP_LEAVE:
827 case OP_LEAVETRY:
a0d0e21e 828 case OP_LEAVELOOP:
79072805 829 case OP_LINESEQ:
79072805 830 case OP_LIST:
79072805
LW		 831 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling)
832 scalarvoid(kid);
833 break;
5aabfad6 834 case OP_REQUIRE:
835 /* since all requires must return a value, they're never void */
836 op->op_flags &= ~OPf_WANT;
837 return scalar(op);
a0d0e21e
LW		 838 case OP_SPLIT:
839 if ((kid = ((LISTOP*)op)->op_first) && kid->op_type == OP_PUSHRE) {
840 if (!kPMOP->op_pmreplroot)
841 deprecate("implicit split to @_");
842 }
843 break;
79072805 844 }
8990e307
LW		 845 if (useless && dowarn)
846 warn("Useless use of %s in void context", useless);
79072805
LW		 847 return op;
848}
849
850OP *
851listkids(op)
852OP *op;
853{
854 OP *kid;
855 if (op && op->op_flags & OPf_KIDS) {
856 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling)
857 list(kid);
858 }
859 return op;
860}
861
862OP *
863list(op)
864OP *op;
865{
866 OP *kid;
867
a0d0e21e 868 /* assumes no premature commitment */
54310121 869 if (!op || (op->op_flags & OPf_WANT) || error_count
870 || op->op_type == OP_RETURN)
79072805
LW		 871 return op;
872
54310121 873 op->op_flags = (op->op_flags & ~OPf_WANT) | OPf_WANT_LIST;
79072805
LW		 874
875 switch (op->op_type) {
876 case OP_FLOP:
877 case OP_REPEAT:
878 list(cBINOP->op_first);
879 break;
880 case OP_OR:
881 case OP_AND:
882 case OP_COND_EXPR:
883 for (kid = cUNOP->op_first->op_sibling; kid; kid = kid->op_sibling)
884 list(kid);
885 break;
886 default:
887 case OP_MATCH:
888 case OP_SUBST:
889 case OP_NULL:
890 if (!(op->op_flags & OPf_KIDS))
891 break;
892 if (!op->op_next && cUNOP->op_first->op_type == OP_FLOP) {
893 list(cBINOP->op_first);
894 return gen_constant_list(op);
895 }
896 case OP_LIST:
897 listkids(op);
898 break;
899 case OP_LEAVE:
900 case OP_LEAVETRY:
54310121 901 kid = cLISTOP->op_first;
902 list(kid);
903 while (kid = kid->op_sibling) {
904 if (kid->op_sibling)
905 scalarvoid(kid);
906 else
907 list(kid);
908 }
909 curcop = &compiling;
910 break;
748a9306 911 case OP_SCOPE:
79072805
LW		 912 case OP_LINESEQ:
913 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling) {
914 if (kid->op_sibling)
915 scalarvoid(kid);
916 else
917 list(kid);
918 }
93a17b20 919 curcop = &compiling;
79072805
LW		 920 break;
921 }
922 return op;
923}
924
925OP *
926scalarseq(op)
927OP *op;
928{
929 OP *kid;
930
463ee0b2
LW		 931 if (op) {
932 if (op->op_type == OP_LINESEQ ||
933 op->op_type == OP_SCOPE ||
79072805 934 op->op_type == OP_LEAVE ||
463ee0b2
LW		 935 op->op_type == OP_LEAVETRY)
936 {
937 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling) {
ed6116ce 938 if (kid->op_sibling) {
463ee0b2 939 scalarvoid(kid);
ed6116ce 940 }
463ee0b2
LW		 941 }
942 curcop = &compiling;
79072805 943 }
463ee0b2 944 op->op_flags &= ~OPf_PARENS;
85e6fe83 945 if (hints & HINT_BLOCK_SCOPE)
463ee0b2 946 op->op_flags |= OPf_PARENS;
79072805 947 }
8990e307
LW		 948 else
949 op = newOP(OP_STUB, 0);
79072805
LW		 950 return op;
951}
952
a0d0e21e 953static OP *
463ee0b2 954modkids(op, type)
79072805
LW		 955OP *op;
956I32 type;
957{
958 OP *kid;
959 if (op && op->op_flags & OPf_KIDS) {
960 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling)
463ee0b2 961 mod(kid, type);
79072805
LW		 962 }
963 return op;
964}
965
463ee0b2 966static I32 modcount;
79072805
LW		 967
968OP *
463ee0b2 969mod(op, type)
79072805
LW		 970OP *op;
971I32 type;
972{
973 OP *kid;
974 SV *sv;
975
a0d0e21e 976 if (!op || error_count)
79072805
LW		 977 return op;
978
979 switch (op->op_type) {
68dc0745 980 case OP_UNDEF:
981 return op;
a0d0e21e 982 case OP_CONST:
748a9306 983 if (!(op->op_private & (OPpCONST_ARYBASE)))
a0d0e21e
LW		 984 goto nomod;
985 if (eval_start && eval_start->op_type == OP_CONST) {
986 compiling.cop_arybase = (I32)SvIV(((SVOP*)eval_start)->op_sv);
987 eval_start = 0;
988 }
989 else if (!type) {
990 SAVEI32(compiling.cop_arybase);
748a9306 991 compiling.cop_arybase = 0;
a0d0e21e
LW		 992 }
993 else if (type == OP_REFGEN)
994 goto nomod;
995 else
996 croak("That use of $[ is unsupported");
997 break;
5f05dabc 998 case OP_STUB:
999 if (op->op_flags & OPf_PARENS)
1000 break;
1001 goto nomod;
a0d0e21e
LW		 1002 case OP_ENTERSUB:
1003 if ((type == OP_UNDEF || type == OP_REFGEN) &&
1004 !(op->op_flags & OPf_STACKED)) {
1005 op->op_type = OP_RV2CV; /* entersub => rv2cv */
93a17b20 1006 op->op_ppaddr = ppaddr[OP_RV2CV];
85e6fe83
LW		 1007 assert(cUNOP->op_first->op_type == OP_NULL);
1008 null(((LISTOP*)cUNOP->op_first)->op_first); /* disable pushmark */
79072805
LW		 1009 break;
1010 }
1011 /* FALL THROUGH */
1012 default:
a0d0e21e
LW		 1013 nomod:
1014 /* grep, foreach, subcalls, refgen */
1015 if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN)
1016 break;
46fc3d4c 1017 yyerror(form("Can't modify %s in %s",
1018 op_desc[op->op_type],
1019 type ? op_desc[type] : "local"));
79072805
LW		 1020 return op;
1021
a0d0e21e
LW		 1022 case OP_PREINC:
1023 case OP_PREDEC:
1024 case OP_POW:
1025 case OP_MULTIPLY:
1026 case OP_DIVIDE:
1027 case OP_MODULO:
1028 case OP_REPEAT:
1029 case OP_ADD:
1030 case OP_SUBTRACT:
1031 case OP_CONCAT:
1032 case OP_LEFT_SHIFT:
1033 case OP_RIGHT_SHIFT:
1034 case OP_BIT_AND:
1035 case OP_BIT_XOR:
1036 case OP_BIT_OR:
1037 case OP_I_MULTIPLY:
1038 case OP_I_DIVIDE:
1039 case OP_I_MODULO:
1040 case OP_I_ADD:
1041 case OP_I_SUBTRACT:
1042 if (!(op->op_flags & OPf_STACKED))
1043 goto nomod;
1044 modcount++;
1045 break;
1046
79072805
LW		 1047 case OP_COND_EXPR:
1048 for (kid = cUNOP->op_first->op_sibling; kid; kid = kid->op_sibling)
463ee0b2 1049 mod(kid, type);
79072805
LW		 1050 break;
1051
1052 case OP_RV2AV:
1053 case OP_RV2HV:
748a9306
LW		 1054 if (type == OP_REFGEN && op->op_flags & OPf_PARENS) {
1055 modcount = 10000;
1056 return op; /* Treat \(@foo) like ordinary list. */
1057 }
1058 /* FALL THROUGH */
79072805 1059 case OP_RV2GV:
3fe9a6f1 1060 if (scalar_mod_type(op, type))
1061 goto nomod;
93a17b20 1062 ref(cUNOP->op_first, op->op_type);
79072805
LW		 1063 /* FALL THROUGH */
1064 case OP_AASSIGN:
1065 case OP_ASLICE:
1066 case OP_HSLICE:
93a17b20
LW		 1067 case OP_NEXTSTATE:
1068 case OP_DBSTATE:
a0d0e21e
LW		 1069 case OP_REFGEN:
1070 case OP_CHOMP:
463ee0b2 1071 modcount = 10000;
79072805 1072 break;
463ee0b2 1073 case OP_RV2SV:
4633a7c4
LW		 1074 if (!type && cUNOP->op_first->op_type != OP_GV)
1075 croak("Can't localize a reference");
8990e307 1076 ref(cUNOP->op_first, op->op_type);
463ee0b2 1077 /* FALL THROUGH */
79072805 1078 case OP_GV:
463ee0b2
LW		 1079 case OP_AV2ARYLEN:
1080 case OP_SASSIGN:
8990e307
LW		 1081 case OP_AELEMFAST:
1082 modcount++;
1083 break;
1084
748a9306
LW		 1085 case OP_PADAV:
1086 case OP_PADHV:
1087 modcount = 10000;
58e0a6ae
GS		 1088 if (type == OP_REFGEN && op->op_flags & OPf_PARENS)
1089 return op; /* Treat \(@foo) like ordinary list. */
3fe9a6f1 1090 if (scalar_mod_type(op, type))
1091 goto nomod;
748a9306
LW		 1092 /* FALL THROUGH */
1093 case OP_PADSV:
1094 modcount++;
1095 if (!type)
1096 croak("Can't localize lexical variable %s",
1097 SvPV(*av_fetch(comppad_name, op->op_targ, 4), na));
463ee0b2
LW		 1098 break;
1099
748a9306
LW		 1100 case OP_PUSHMARK:
1101 break;
a0d0e21e 1102
69969c6f
SB		 1103 case OP_KEYS:
1104 if (type != OP_SASSIGN)
1105 goto nomod;
5f05dabc 1106 /* FALL THROUGH */
a0d0e21e 1107 case OP_POS:
463ee0b2 1108 case OP_VEC:
a0d0e21e 1109 case OP_SUBSTR:
8990e307 1110 pad_free(op->op_targ);
ed6116ce 1111 op->op_targ = pad_alloc(op->op_type, SVs_PADMY);
5f05dabc 1112 assert(SvTYPE(PAD_SV(op->op_targ)) == SVt_NULL);
8990e307 1113 if (op->op_flags & OPf_KIDS)
4633a7c4 1114 mod(cBINOP->op_first->op_sibling, type);
463ee0b2 1115 break;
a0d0e21e 1116
463ee0b2
LW		 1117 case OP_AELEM:
1118 case OP_HELEM:
8990e307 1119 ref(cBINOP->op_first, op->op_type);
68dc0745 1120 if (type == OP_ENTERSUB &&
1121 !(op->op_private & (OPpLVAL_INTRO | OPpDEREF)))
1122 op->op_private |= OPpLVAL_DEFER;
a0d0e21e 1123 modcount++;
463ee0b2
LW		 1124 break;
1125
1126 case OP_SCOPE:
1127 case OP_LEAVE:
1128 case OP_ENTER:
a0d0e21e
LW		 1129 if (op->op_flags & OPf_KIDS)
1130 mod(cLISTOP->op_last, type);
1131 break;
1132
1133 case OP_NULL:
463ee0b2
LW		 1134 if (!(op->op_flags & OPf_KIDS))
1135 break;
a0d0e21e
LW		 1136 if (op->op_targ != OP_LIST) {
1137 mod(cBINOP->op_first, type);
1138 break;
1139 }
1140 /* FALL THROUGH */
463ee0b2
LW		 1141 case OP_LIST:
1142 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling)
1143 mod(kid, type);
1144 break;
1145 }
a0d0e21e
LW		 1146 op->op_flags |= OPf_MOD;
1147
1148 if (type == OP_AASSIGN || type == OP_SASSIGN)
1149 op->op_flags |= OPf_SPECIAL|OPf_REF;
1150 else if (!type) {
1151 op->op_private |= OPpLVAL_INTRO;
463ee0b2 1152 op->op_flags &= ~OPf_SPECIAL;
463ee0b2 1153 }
a0d0e21e
LW		 1154 else if (type != OP_GREPSTART && type != OP_ENTERSUB)
1155 op->op_flags |= OPf_REF;
463ee0b2
LW		 1156 return op;
1157}
1158
3fe9a6f1 1159static bool
1160scalar_mod_type(op, type)
1161OP *op;
1162I32 type;
1163{
1164 switch (type) {
1165 case OP_SASSIGN:
1166 if (op->op_type == OP_RV2GV)
1167 return FALSE;
1168 /* FALL THROUGH */
1169 case OP_PREINC:
1170 case OP_PREDEC:
1171 case OP_POSTINC:
1172 case OP_POSTDEC:
1173 case OP_I_PREINC:
1174 case OP_I_PREDEC:
1175 case OP_I_POSTINC:
1176 case OP_I_POSTDEC:
1177 case OP_POW:
1178 case OP_MULTIPLY:
1179 case OP_DIVIDE:
1180 case OP_MODULO:
1181 case OP_REPEAT:
1182 case OP_ADD:
1183 case OP_SUBTRACT:
1184 case OP_I_MULTIPLY:
1185 case OP_I_DIVIDE:
1186 case OP_I_MODULO:
1187 case OP_I_ADD:
1188 case OP_I_SUBTRACT:
1189 case OP_LEFT_SHIFT:
1190 case OP_RIGHT_SHIFT:
1191 case OP_BIT_AND:
1192 case OP_BIT_XOR:
1193 case OP_BIT_OR:
1194 case OP_CONCAT:
1195 case OP_SUBST:
1196 case OP_TRANS:
1197 case OP_ANDASSIGN: /* may work later */
1198 case OP_ORASSIGN: /* may work later */
1199 return TRUE;
1200 default:
1201 return FALSE;
1202 }
1203}
1204
463ee0b2
LW		 1205OP *
1206refkids(op, type)
1207OP *op;
1208I32 type;
1209{
1210 OP *kid;
1211 if (op && op->op_flags & OPf_KIDS) {
1212 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling)
1213 ref(kid, type);
1214 }
1215 return op;
1216}
1217
1218OP *
1219ref(op, type)
1220OP *op;
1221I32 type;
1222{
1223 OP *kid;
463ee0b2 1224
a0d0e21e 1225 if (!op || error_count)
463ee0b2
LW		 1226 return op;
1227
1228 switch (op->op_type) {
a0d0e21e
LW		 1229 case OP_ENTERSUB:
1230 if ((type == OP_DEFINED) &&
1231 !(op->op_flags & OPf_STACKED)) {
1232 op->op_type = OP_RV2CV; /* entersub => rv2cv */
8990e307 1233 op->op_ppaddr = ppaddr[OP_RV2CV];
85e6fe83
LW		 1234 assert(cUNOP->op_first->op_type == OP_NULL);
1235 null(((LISTOP*)cUNOP->op_first)->op_first); /* disable pushmark */
4633a7c4 1236 op->op_flags |= OPf_SPECIAL;
8990e307
LW		 1237 }
1238 break;
1239
463ee0b2
LW		 1240 case OP_COND_EXPR:
1241 for (kid = cUNOP->op_first->op_sibling; kid; kid = kid->op_sibling)
1242 ref(kid, type);
1243 break;
8990e307 1244 case OP_RV2SV:
8990e307 1245 ref(cUNOP->op_first, op->op_type);
4633a7c4
LW		 1246 /* FALL THROUGH */
1247 case OP_PADSV:
5f05dabc 1248 if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
1249 op->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1250 : type == OP_RV2HV ? OPpDEREF_HV
1251 : OPpDEREF_SV);
a0d0e21e
LW		 1252 op->op_flags |= OPf_MOD;
1253 }
8990e307
LW		 1254 break;
1255
463ee0b2
LW		 1256 case OP_RV2AV:
1257 case OP_RV2HV:
a0d0e21e 1258 op->op_flags |= OPf_REF;
8990e307 1259 /* FALL THROUGH */
463ee0b2
LW		 1260 case OP_RV2GV:
1261 ref(cUNOP->op_first, op->op_type);
463ee0b2 1262 break;
8990e307 1263
463ee0b2
LW		 1264 case OP_PADAV:
1265 case OP_PADHV:
a0d0e21e 1266 op->op_flags |= OPf_REF;
79072805 1267 break;
8990e307
LW		 1268
1269 case OP_SCALAR:
79072805
LW		 1270 case OP_NULL:
1271 if (!(op->op_flags & OPf_KIDS))
463ee0b2 1272 break;
8990e307 1273 ref(cBINOP->op_first, type);
79072805
LW		 1274 break;
1275 case OP_AELEM:
1276 case OP_HELEM:
8990e307 1277 ref(cBINOP->op_first, op->op_type);
5f05dabc 1278 if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
1279 op->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1280 : type == OP_RV2HV ? OPpDEREF_HV
1281 : OPpDEREF_SV);
a0d0e21e 1282 op->op_flags |= OPf_MOD;
8990e307 1283 }
79072805
LW		 1284 break;
1285
463ee0b2 1286 case OP_SCOPE:
79072805
LW		 1287 case OP_LEAVE:
1288 case OP_ENTER:
8990e307 1289 case OP_LIST:
79072805
LW		 1290 if (!(op->op_flags & OPf_KIDS))
1291 break;
8990e307 1292 ref(cLISTOP->op_last, type);
79072805 1293 break;
a0d0e21e
LW		 1294 default:
1295 break;
79072805 1296 }
8990e307
LW		 1297 return scalar(op);
1298
79072805
LW		 1299}
1300
1301OP *
93a17b20
LW		 1302my(op)
1303OP *op;
1304{
1305 OP *kid;
93a17b20
LW		 1306 I32 type;
1307
a0d0e21e 1308 if (!op || error_count)
93a17b20
LW		 1309 return op;
1310
1311 type = op->op_type;
1312 if (type == OP_LIST) {
1313 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling)
1314 my(kid);
1315 }
1316 else if (type != OP_PADSV &&
1317 type != OP_PADAV &&
1318 type != OP_PADHV &&
1319 type != OP_PUSHMARK)
1320 {
46fc3d4c 1321 yyerror(form("Can't declare %s in my", op_desc[op->op_type]));
93a17b20
LW		 1322 return op;
1323 }
a0d0e21e
LW		 1324 op->op_flags |= OPf_MOD;
1325 op->op_private |= OPpLVAL_INTRO;
93a17b20
LW		 1326 return op;
1327}
1328
1329OP *
79072805
LW		 1330sawparens(o)
1331OP *o;
1332{
1333 if (o)
1334 o->op_flags |= OPf_PARENS;
1335 return o;
1336}
1337
1338OP *
1339bind_match(type, left, right)
1340I32 type;
1341OP *left;
1342OP *right;
1343{
1344 OP *op;
1345
2ae324a7 1346 if (dowarn &&
1347 (left->op_type == OP_RV2AV ||
1348 left->op_type == OP_RV2HV ||
1349 left->op_type == OP_PADAV ||
1350 left->op_type == OP_PADHV)) {
1351 char *desc = op_desc[(right->op_type == OP_SUBST ||
1352 right->op_type == OP_TRANS)
1353 ? right->op_type : OP_MATCH];
1354 char *sample = ((left->op_type == OP_RV2AV ||
1355 left->op_type == OP_PADAV)
1356 ? "@array" : "%hash");
1357 warn("Applying %s to %s will act on scalar(%s)", desc, sample, sample);
1358 }
1359
79072805
LW		 1360 if (right->op_type == OP_MATCH ||
1361 right->op_type == OP_SUBST ||
1362 right->op_type == OP_TRANS) {
1363 right->op_flags |= OPf_STACKED;
1364 if (right->op_type != OP_MATCH)
463ee0b2 1365 left = mod(left, right->op_type);
79072805 1366 if (right->op_type == OP_TRANS)
a0d0e21e 1367 op = newBINOP(OP_NULL, OPf_STACKED, scalar(left), right);
79072805
LW		 1368 else
1369 op = prepend_elem(right->op_type, scalar(left), right);
1370 if (type == OP_NOT)
1371 return newUNOP(OP_NOT, 0, scalar(op));
1372 return op;
1373 }
1374 else
1375 return bind_match(type, left,
1376 pmruntime(newPMOP(OP_MATCH, 0), right, Nullop));
1377}
1378
1379OP *
1380invert(op)
1381OP *op;
1382{
1383 if (!op)
1384 return op;
1385 /* XXX need to optimize away NOT NOT here? Or do we let optimizer do it? */
1386 return newUNOP(OP_NOT, OPf_SPECIAL, scalar(op));
1387}
1388
1389OP *
1390scope(o)
1391OP *o;
1392{
1393 if (o) {
4633a7c4 1394 if (o->op_flags & OPf_PARENS || perldb || tainting) {
463ee0b2
LW		 1395 o = prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
1396 o->op_type = OP_LEAVE;
1397 o->op_ppaddr = ppaddr[OP_LEAVE];
1398 }
1399 else {
1400 if (o->op_type == OP_LINESEQ) {
1401 OP *kid;
1402 o->op_type = OP_SCOPE;
1403 o->op_ppaddr = ppaddr[OP_SCOPE];
1404 kid = ((LISTOP*)o)->op_first;
748a9306
LW		 1405 if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE){
1406 SvREFCNT_dec(((COP*)kid)->cop_filegv);
8990e307 1407 null(kid);
748a9306 1408 }
463ee0b2
LW		 1409 }
1410 else
748a9306 1411 o = newLISTOP(OP_SCOPE, 0, o, Nullop);
463ee0b2 1412 }
79072805
LW		 1413 }
1414 return o;
1415}
1416
a0d0e21e 1417int
55497cff 1418block_start(full)
1419int full;
79072805 1420{
a0d0e21e 1421 int retval = savestack_ix;
55497cff 1422 SAVEI32(comppad_name_floor);
1423 if (full) {
1424 if ((comppad_name_fill = AvFILL(comppad_name)) > 0)
1425 comppad_name_floor = comppad_name_fill;
1426 else
1427 comppad_name_floor = 0;
1428 }
1429 SAVEI32(min_intro_pending);
1430 SAVEI32(max_intro_pending);
a0d0e21e 1431 min_intro_pending = 0;
55497cff 1432 SAVEI32(comppad_name_fill);
1433 SAVEI32(padix_floor);
a0d0e21e
LW		 1434 padix_floor = padix;
1435 pad_reset_pending = FALSE;
55497cff 1436 SAVEI32(hints);
a0d0e21e
LW		 1437 hints &= ~HINT_BLOCK_SCOPE;
1438 return retval;
1439}
1440
1441OP*
36477c24 1442block_end(floor, seq)
1443I32 floor;
a0d0e21e
LW		 1444OP* seq;
1445{
1446 int needblockscope = hints & HINT_BLOCK_SCOPE;
1447 OP* retval = scalarseq(seq);
a0d0e21e
LW		 1448 LEAVE_SCOPE(floor);
1449 pad_reset_pending = FALSE;
1450 if (needblockscope)
1451 hints |= HINT_BLOCK_SCOPE; /* propagate out */
1452 pad_leavemy(comppad_name_fill);
bbce6d69 1453 cop_seqmax++;
a0d0e21e
LW		 1454 return retval;
1455}
1456
1457void
1458newPROG(op)
1459OP *op;
1460{
1461 if (in_eval) {
b1cb66bf 1462 eval_root = newUNOP(OP_LEAVEEVAL, ((in_eval & 4) ? OPf_SPECIAL : 0), op);
a0d0e21e
LW		 1463 eval_start = linklist(eval_root);
1464 eval_root->op_next = 0;
1465 peep(eval_start);
1466 }
1467 else {
4fdae800 1468 if (!op)
a0d0e21e 1469 return;
a0d0e21e
LW		 1470 main_root = scope(sawparens(scalarvoid(op)));
1471 curcop = &compiling;
1472 main_start = LINKLIST(main_root);
1473 main_root->op_next = 0;
1474 peep(main_start);
748a9306 1475 compcv = 0;
3841441e 1476
4fdae800 1477 /* Register with debugger */
3841441e
CS		 1478 if (perldb) {
1479 CV *cv = perl_get_cv("DB::postponed", FALSE);
3841441e
CS		 1480 if (cv) {
1481 dSP;
1482 PUSHMARK(sp);
1483 XPUSHs((SV*)compiling.cop_filegv);
1484 PUTBACK;
1485 perl_call_sv((SV*)cv, G_DISCARD);
1486 }
1487 }
79072805 1488 }
79072805
LW		 1489}
1490
1491OP *
93a17b20 1492localize(o, lex)
79072805 1493OP *o;
93a17b20 1494I32 lex;
79072805
LW		 1495{
1496 if (o->op_flags & OPf_PARENS)
1497 list(o);
8990e307 1498 else {
79072805 1499 scalar(o);
8990e307
LW		 1500 if (dowarn && bufptr > oldbufptr && bufptr[-1] == ',') {
1501 char *s;
1502 for (s = bufptr; *s && (isALNUM(*s) || strchr("@$%, ",*s)); s++) ;
a0d0e21e 1503 if (*s == ';' || *s == '=')
8990e307
LW		 1504 warn("Parens missing around \"%s\" list", lex ? "my" : "local");
1505 }
1506 }
93a17b20
LW		 1507 in_my = FALSE;
1508 if (lex)
1509 return my(o);
1510 else
463ee0b2 1511 return mod(o, OP_NULL); /* a bit kludgey */
79072805
LW		 1512}
1513
1514OP *
1515jmaybe(o)
1516OP *o;
1517{
1518 if (o->op_type == OP_LIST) {
1519 o = convert(OP_JOIN, 0,
1520 prepend_elem(OP_LIST,
85e6fe83 1521 newSVREF(newGVOP(OP_GV, 0, gv_fetchpv(";", TRUE, SVt_PV))),
79072805
LW		 1522 o));
1523 }
1524 return o;
1525}
1526
1527OP *
1528fold_constants(o)
1529register OP *o;
1530{
1531 register OP *curop;
1532 I32 type = o->op_type;
748a9306 1533 SV *sv;
79072805
LW		 1534
1535 if (opargs[type] & OA_RETSCALAR)
1536 scalar(o);
1537 if (opargs[type] & OA_TARGET)
ed6116ce 1538 o->op_targ = pad_alloc(type, SVs_PADTMP);
79072805 1539
85e6fe83 1540 if ((opargs[type] & OA_OTHERINT) && (hints & HINT_INTEGER))
a0d0e21e 1541 o->op_ppaddr = ppaddr[type = ++(o->op_type)];
85e6fe83 1542
79072805
LW		 1543 if (!(opargs[type] & OA_FOLDCONST))
1544 goto nope;
1545
a0d0e21e
LW		 1546 if (error_count)
1547 goto nope; /* Don't try to run w/ errors */
1548
79072805 1549 for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
93a17b20
LW		 1550 if (curop->op_type != OP_CONST &&
1551 curop->op_type != OP_LIST &&
1552 curop->op_type != OP_SCALAR &&
a0d0e21e 1553 curop->op_type != OP_NULL &&
93a17b20 1554 curop->op_type != OP_PUSHMARK) {
79072805
LW		 1555 goto nope;
1556 }
1557 }
1558
1559 curop = LINKLIST(o);
1560 o->op_next = 0;
1561 op = curop;
8da795c6 1562 runops();
748a9306
LW		 1563 sv = *(stack_sp--);
1564 if (o->op_targ && sv == PAD_SV(o->op_targ)) /* grab pad temp? */
79072805 1565 pad_swipe(o->op_targ);
748a9306
LW		 1566 else if (SvTEMP(sv)) { /* grab mortal temp? */
1567 (void)SvREFCNT_inc(sv);
1568 SvTEMP_off(sv);
85e6fe83 1569 }
79072805
LW		 1570 op_free(o);
1571 if (type == OP_RV2GV)
b1cb66bf 1572 return newGVOP(OP_GV, 0, (GV*)sv);
748a9306
LW		 1573 else {
1574 if ((SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK)) == SVf_NOK) {
1575 IV iv = SvIV(sv);
1576 if ((double)iv == SvNV(sv)) { /* can we smush double to int */
1577 SvREFCNT_dec(sv);
1578 sv = newSViv(iv);
1579 }
b1cb66bf 1580 else
1581 SvIOK_off(sv); /* undo SvIV() damage */
748a9306
LW		 1582 }
1583 return newSVOP(OP_CONST, 0, sv);
1584 }
79072805
LW		 1585
1586 nope:
1587 if (!(opargs[type] & OA_OTHERINT))
1588 return o;
79072805 1589
85e6fe83 1590 if (!(hints & HINT_INTEGER)) {
a0d0e21e 1591 if (type == OP_DIVIDE || !(o->op_flags & OPf_KIDS))
85e6fe83
LW		 1592 return o;
1593
1594 for (curop = ((UNOP*)o)->op_first; curop; curop = curop->op_sibling) {
1595 if (curop->op_type == OP_CONST) {
b1cb66bf 1596 if (SvIOK(((SVOP*)curop)->op_sv))
85e6fe83
LW		 1597 continue;
1598 return o;
1599 }
1600 if (opargs[curop->op_type] & OA_RETINTEGER)
79072805
LW		 1601 continue;
1602 return o;
1603 }
a0d0e21e 1604 o->op_ppaddr = ppaddr[++(o->op_type)];
79072805
LW		 1605 }
1606
79072805
LW		 1607 return o;
1608}
1609
1610OP *
1611gen_constant_list(o)
1612register OP *o;
1613{
1614 register OP *curop;
79072805 1615 I32 oldtmps_floor = tmps_floor;
79072805 1616
a0d0e21e
LW		 1617 list(o);
1618 if (error_count)
1619 return o; /* Don't attempt to run with errors */
1620
1621 op = curop = LINKLIST(o);
1622 o->op_next = 0;
1623 pp_pushmark();
8da795c6 1624 runops();
a0d0e21e
LW		 1625 op = curop;
1626 pp_anonlist();
79072805 1627 tmps_floor = oldtmps_floor;
79072805
LW		 1628
1629 o->op_type = OP_RV2AV;
1630 o->op_ppaddr = ppaddr[OP_RV2AV];
79072805 1631 curop = ((UNOP*)o)->op_first;
a0d0e21e 1632 ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc(*stack_sp--));
79072805 1633 op_free(curop);
79072805
LW		 1634 linklist(o);
1635 return list(o);
1636}
1637
1638OP *
1639convert(type, flags, op)
1640I32 type;
1641I32 flags;
1642OP* op;
1643{
1644 OP *kid;
a0d0e21e 1645 OP *last = 0;
79072805 1646
79072805
LW		 1647 if (!op || op->op_type != OP_LIST)
1648 op = newLISTOP(OP_LIST, 0, op, Nullop);
748a9306 1649 else
54310121 1650 op->op_flags &= ~OPf_WANT;
79072805 1651
8990e307
LW		 1652 if (!(opargs[type] & OA_MARK))
1653 null(cLISTOP->op_first);
1654
79072805
LW		 1655 op->op_type = type;
1656 op->op_ppaddr = ppaddr[type];
1657 op->op_flags |= flags;
1658
e50aee73 1659 op = CHECKOP(type, op);
79072805
LW		 1660 if (op->op_type != type)
1661 return op;
1662
1663 if (cLISTOP->op_children < 7) {
1664 /* XXX do we really need to do this if we're done appending?? */
1665 for (kid = cLISTOP->op_first; kid; kid = kid->op_sibling)
1666 last = kid;
1667 cLISTOP->op_last = last; /* in case check substituted last arg */
1668 }
1669
1670 return fold_constants(op);
1671}
1672
1673/* List constructors */
1674
1675OP *
1676append_elem(type, first, last)
1677I32 type;
1678OP* first;
1679OP* last;
1680{
1681 if (!first)
1682 return last;
8990e307
LW		 1683
1684 if (!last)
79072805 1685 return first;
8990e307 1686
a0d0e21e
LW		 1687 if (first->op_type != type || type==OP_LIST && first->op_flags & OPf_PARENS)
1688 return newLISTOP(type, 0, first, last);
79072805 1689
a0d0e21e
LW		 1690 if (first->op_flags & OPf_KIDS)
1691 ((LISTOP*)first)->op_last->op_sibling = last;
1692 else {
1693 first->op_flags |= OPf_KIDS;
1694 ((LISTOP*)first)->op_first = last;
1695 }
1696 ((LISTOP*)first)->op_last = last;
1697 ((LISTOP*)first)->op_children++;
1698 return first;
79072805
LW		 1699}
1700
1701OP *
1702append_list(type, first, last)
1703I32 type;
1704LISTOP* first;
1705LISTOP* last;
1706{
1707 if (!first)
1708 return (OP*)last;
8990e307
LW		 1709
1710 if (!last)
79072805 1711 return (OP*)first;
8990e307
LW		 1712
1713 if (first->op_type != type)
79072805 1714 return prepend_elem(type, (OP*)first, (OP*)last);
8990e307
LW		 1715
1716 if (last->op_type != type)
79072805
LW		 1717 return append_elem(type, (OP*)first, (OP*)last);
1718
1719 first->op_last->op_sibling = last->op_first;
1720 first->op_last = last->op_last;
1721 first->op_children += last->op_children;
1722 if (first->op_children)
1723 last->op_flags |= OPf_KIDS;
1724
1725 Safefree(last);
1726 return (OP*)first;
1727}
1728
1729OP *
1730prepend_elem(type, first, last)
1731I32 type;
1732OP* first;
1733OP* last;
1734{
1735 if (!first)
1736 return last;
8990e307
LW		 1737
1738 if (!last)
79072805 1739 return first;
8990e307
LW		 1740
1741 if (last->op_type == type) {
1742 if (type == OP_LIST) { /* already a PUSHMARK there */
1743 first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
1744 ((LISTOP*)last)->op_first->op_sibling = first;
1745 }
1746 else {
1747 if (!(last->op_flags & OPf_KIDS)) {
1748 ((LISTOP*)last)->op_last = first;
1749 last->op_flags |= OPf_KIDS;
1750 }
1751 first->op_sibling = ((LISTOP*)last)->op_first;
1752 ((LISTOP*)last)->op_first = first;
79072805 1753 }
79072805
LW		 1754 ((LISTOP*)last)->op_children++;
1755 return last;
1756 }
1757
1758 return newLISTOP(type, 0, first, last);
1759}
1760
1761/* Constructors */
1762
1763OP *
1764newNULLLIST()
1765{
8990e307
LW		 1766 return newOP(OP_STUB, 0);
1767}
1768
1769OP *
1770force_list(op)
1771OP* op;
1772{
1773 if (!op || op->op_type != OP_LIST)
1774 op = newLISTOP(OP_LIST, 0, op, Nullop);
1775 null(op);
1776 return op;
79072805
LW		 1777}
1778
1779OP *
1780newLISTOP(type, flags, first, last)
1781I32 type;
1782I32 flags;
1783OP* first;
1784OP* last;
1785{
1786 LISTOP *listop;
1787
1788 Newz(1101, listop, 1, LISTOP);
1789
1790 listop->op_type = type;
1791 listop->op_ppaddr = ppaddr[type];
1792 listop->op_children = (first != 0) + (last != 0);
1793 listop->op_flags = flags;
79072805
LW		 1794
1795 if (!last && first)
1796 last = first;
1797 else if (!first && last)
1798 first = last;
8990e307
LW		 1799 else if (first)
1800 first->op_sibling = last;
79072805
LW		 1801 listop->op_first = first;
1802 listop->op_last = last;
8990e307
LW		 1803 if (type == OP_LIST) {
1804 OP* pushop;
1805 pushop = newOP(OP_PUSHMARK, 0);
1806 pushop->op_sibling = first;
1807 listop->op_first = pushop;
1808 listop->op_flags |= OPf_KIDS;
1809 if (!last)
1810 listop->op_last = pushop;
1811 }
1812 else if (listop->op_children)
1813 listop->op_flags |= OPf_KIDS;
79072805
LW		 1814
1815 return (OP*)listop;
1816}
1817
1818OP *
1819newOP(type, flags)
1820I32 type;
1821I32 flags;
1822{
1823 OP *op;
1824 Newz(1101, op, 1, OP);
1825 op->op_type = type;
1826 op->op_ppaddr = ppaddr[type];
1827 op->op_flags = flags;
1828
1829 op->op_next = op;
c07a80fd 1830 op->op_private = 0 + (flags >> 8);
79072805
LW		 1831 if (opargs[type] & OA_RETSCALAR)
1832 scalar(op);
1833 if (opargs[type] & OA_TARGET)
ed6116ce 1834 op->op_targ = pad_alloc(type, SVs_PADTMP);
e50aee73 1835 return CHECKOP(type, op);
79072805
LW		 1836}
1837
1838OP *
1839newUNOP(type, flags, first)
1840I32 type;
1841I32 flags;
1842OP* first;
1843{
1844 UNOP *unop;
1845
93a17b20
LW		 1846 if (!first)
1847 first = newOP(OP_STUB, 0);
8990e307
LW		 1848 if (opargs[type] & OA_MARK)
1849 first = force_list(first);
93a17b20 1850
79072805
LW		 1851 Newz(1101, unop, 1, UNOP);
1852 unop->op_type = type;
1853 unop->op_ppaddr = ppaddr[type];
1854 unop->op_first = first;
1855 unop->op_flags = flags | OPf_KIDS;
c07a80fd 1856 unop->op_private = 1 | (flags >> 8);
79072805 1857
e50aee73 1858 unop = (UNOP*) CHECKOP(type, unop);
79072805
LW		 1859 if (unop->op_next)
1860 return (OP*)unop;
1861
a0d0e21e 1862 return fold_constants((OP *) unop);
79072805
LW		 1863}
1864
1865OP *
1866newBINOP(type, flags, first, last)
1867I32 type;
1868I32 flags;
1869OP* first;
1870OP* last;
1871{
1872 BINOP *binop;
1873 Newz(1101, binop, 1, BINOP);
1874
1875 if (!first)
1876 first = newOP(OP_NULL, 0);
1877
1878 binop->op_type = type;
1879 binop->op_ppaddr = ppaddr[type];
1880 binop->op_first = first;
1881 binop->op_flags = flags | OPf_KIDS;
1882 if (!last) {
1883 last = first;
c07a80fd 1884 binop->op_private = 1 | (flags >> 8);
79072805
LW		 1885 }
1886 else {
c07a80fd 1887 binop->op_private = 2 | (flags >> 8);
79072805
LW		 1888 first->op_sibling = last;
1889 }
1890
e50aee73 1891 binop = (BINOP*)CHECKOP(type, binop);
79072805
LW		 1892 if (binop->op_next)
1893 return (OP*)binop;
1894
1895 binop->op_last = last = binop->op_first->op_sibling;
1896
a0d0e21e 1897 return fold_constants((OP *)binop);
79072805
LW		 1898}
1899
1900OP *
1901pmtrans(op, expr, repl)
1902OP *op;
1903OP *expr;
1904OP *repl;
1905{
79072805
LW		 1906 SV *tstr = ((SVOP*)expr)->op_sv;
1907 SV *rstr = ((SVOP*)repl)->op_sv;
463ee0b2
LW		 1908 STRLEN tlen;
1909 STRLEN rlen;
ec49126f 1910 register U8 *t = (U8*)SvPV(tstr, tlen);
1911 register U8 *r = (U8*)SvPV(rstr, rlen);
79072805
LW		 1912 register I32 i;
1913 register I32 j;
79072805
LW		 1914 I32 delete;
1915 I32 complement;
1916 register short *tbl;
1917
1918 tbl = (short*)cPVOP->op_pv;
1919 complement = op->op_private & OPpTRANS_COMPLEMENT;
1920 delete = op->op_private & OPpTRANS_DELETE;
748a9306 1921 /* squash = op->op_private & OPpTRANS_SQUASH; */
79072805
LW		 1922
1923 if (complement) {
1924 Zero(tbl, 256, short);
1925 for (i = 0; i < tlen; i++)
ec49126f 1926 tbl[t[i]] = -1;
79072805
LW		 1927 for (i = 0, j = 0; i < 256; i++) {
1928 if (!tbl[i]) {
1929 if (j >= rlen) {
1930 if (delete)
1931 tbl[i] = -2;
1932 else if (rlen)
ec49126f 1933 tbl[i] = r[j-1];
79072805
LW		 1934 else
1935 tbl[i] = i;
1936 }
1937 else
ec49126f 1938 tbl[i] = r[j++];
79072805
LW		 1939 }
1940 }
1941 }
1942 else {
1943 if (!rlen && !delete) {
1944 r = t; rlen = tlen;
1945 }
1946 for (i = 0; i < 256; i++)
1947 tbl[i] = -1;
1948 for (i = 0, j = 0; i < tlen; i++,j++) {
1949 if (j >= rlen) {
1950 if (delete) {
ec49126f 1951 if (tbl[t[i]] == -1)
1952 tbl[t[i]] = -2;
79072805
LW		 1953 continue;
1954 }
1955 --j;
1956 }
ec49126f 1957 if (tbl[t[i]] == -1)
1958 tbl[t[i]] = r[j];
79072805
LW		 1959 }
1960 }
1961 op_free(expr);
1962 op_free(repl);
1963
1964 return op;
1965}
1966
1967OP *
1968newPMOP(type, flags)
1969I32 type;
1970I32 flags;
1971{
1972 PMOP *pmop;
1973
1974 Newz(1101, pmop, 1, PMOP);
1975 pmop->op_type = type;
1976 pmop->op_ppaddr = ppaddr[type];
1977 pmop->op_flags = flags;
c07a80fd 1978 pmop->op_private = 0 | (flags >> 8);
79072805 1979
36477c24 1980 if (hints & HINT_LOCALE)
1981 pmop->op_pmpermflags = (pmop->op_pmflags |= PMf_LOCALE);
1982
79072805 1983 /* link into pm list */
a0d0e21e 1984 if (type != OP_TRANS && curstash) {
79072805
LW		 1985 pmop->op_pmnext = HvPMROOT(curstash);
1986 HvPMROOT(curstash) = pmop;
1987 }
1988
1989 return (OP*)pmop;
1990}
1991
1992OP *
1993pmruntime(op, expr, repl)
1994OP *op;
1995OP *expr;
1996OP *repl;
1997{
1998 PMOP *pm;
1999 LOGOP *rcop;
2000
2001 if (op->op_type == OP_TRANS)
2002 return pmtrans(op, expr, repl);
2003
2004 pm = (PMOP*)op;
2005
2006 if (expr->op_type == OP_CONST) {
463ee0b2 2007 STRLEN plen;
79072805 2008 SV *pat = ((SVOP*)expr)->op_sv;
463ee0b2 2009 char *p = SvPV(pat, plen);
79072805 2010 if ((op->op_flags & OPf_SPECIAL) && strEQ(p, " ")) {
93a17b20 2011 sv_setpvn(pat, "\\s+", 3);
463ee0b2 2012 p = SvPV(pat, plen);
79072805
LW		 2013 pm->op_pmflags |= PMf_SKIPWHITE;
2014 }
e50aee73 2015 pm->op_pmregexp = pregcomp(p, p + plen, pm);
85e6fe83
LW		 2016 if (strEQ("\\s+", pm->op_pmregexp->precomp))
2017 pm->op_pmflags |= PMf_WHITE;
79072805
LW		 2018 hoistmust(pm);
2019 op_free(expr);
2020 }
2021 else {
463ee0b2
LW		 2022 if (pm->op_pmflags & PMf_KEEP)
2023 expr = newUNOP(OP_REGCMAYBE,0,expr);
2024
79072805
LW		 2025 Newz(1101, rcop, 1, LOGOP);
2026 rcop->op_type = OP_REGCOMP;
2027 rcop->op_ppaddr = ppaddr[OP_REGCOMP];
2028 rcop->op_first = scalar(expr);
2029 rcop->op_flags |= OPf_KIDS;
2030 rcop->op_private = 1;
2031 rcop->op_other = op;
2032
2033 /* establish postfix order */
463ee0b2
LW		 2034 if (pm->op_pmflags & PMf_KEEP) {
2035 LINKLIST(expr);
2036 rcop->op_next = expr;
2037 ((UNOP*)expr)->op_first->op_next = (OP*)rcop;
2038 }
2039 else {
2040 rcop->op_next = LINKLIST(expr);
2041 expr->op_next = (OP*)rcop;
2042 }
79072805 2043
463ee0b2 2044 prepend_elem(op->op_type, scalar((OP*)rcop), op);
79072805
LW		 2045 }
2046
2047 if (repl) {
748a9306
LW		 2048 OP *curop;
2049 if (pm->op_pmflags & PMf_EVAL)
2050 curop = 0;
2051 else if (repl->op_type == OP_CONST)
2052 curop = repl;
79072805 2053 else {
79072805
LW		 2054 OP *lastop = 0;
2055 for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
2056 if (opargs[curop->op_type] & OA_DANGEROUS) {
2057 if (curop->op_type == OP_GV) {
2058 GV *gv = ((GVOP*)curop)->op_gv;
93a17b20 2059 if (strchr("&`'123456789+", *GvENAME(gv)))
79072805
LW		 2060 break;
2061 }
2062 else if (curop->op_type == OP_RV2CV)
2063 break;
2064 else if (curop->op_type == OP_RV2SV ||
2065 curop->op_type == OP_RV2AV ||
2066 curop->op_type == OP_RV2HV ||
2067 curop->op_type == OP_RV2GV) {
2068 if (lastop && lastop->op_type != OP_GV) /*funny deref?*/
2069 break;
2070 }
748a9306
LW		 2071 else if (curop->op_type == OP_PADSV ||
2072 curop->op_type == OP_PADAV ||
2073 curop->op_type == OP_PADHV ||
2074 curop->op_type == OP_PADANY) {
2075 /* is okay */
2076 }
79072805
LW		 2077 else
2078 break;
2079 }
2080 lastop = curop;
2081 }
748a9306
LW		 2082 }
2083 if (curop == repl) {
2084 pm->op_pmflags |= PMf_CONST; /* const for long enough */
4633a7c4 2085 pm->op_pmpermflags |= PMf_CONST; /* const for long enough */
748a9306
LW		 2086 prepend_elem(op->op_type, scalar(repl), op);
2087 }
2088 else {
2089 Newz(1101, rcop, 1, LOGOP);
2090 rcop->op_type = OP_SUBSTCONT;
2091 rcop->op_ppaddr = ppaddr[OP_SUBSTCONT];
2092 rcop->op_first = scalar(repl);
2093 rcop->op_flags |= OPf_KIDS;
2094 rcop->op_private = 1;
2095 rcop->op_other = op;
2096
2097 /* establish postfix order */
2098 rcop->op_next = LINKLIST(repl);
2099 repl->op_next = (OP*)rcop;
2100
2101 pm->op_pmreplroot = scalar((OP*)rcop);
2102 pm->op_pmreplstart = LINKLIST(rcop);
2103 rcop->op_next = 0;
79072805
LW		 2104 }
2105 }
2106
2107 return (OP*)pm;
2108}
2109
2110OP *
2111newSVOP(type, flags, sv)
2112I32 type;
2113I32 flags;
2114SV *sv;
2115{
2116 SVOP *svop;
2117 Newz(1101, svop, 1, SVOP);
2118 svop->op_type = type;
2119 svop->op_ppaddr = ppaddr[type];
2120 svop->op_sv = sv;
2121 svop->op_next = (OP*)svop;
2122 svop->op_flags = flags;
2123 if (opargs[type] & OA_RETSCALAR)
463ee0b2 2124 scalar((OP*)svop);
79072805 2125 if (opargs[type] & OA_TARGET)
ed6116ce 2126 svop->op_targ = pad_alloc(type, SVs_PADTMP);
e50aee73 2127 return CHECKOP(type, svop);
79072805
LW		 2128}
2129
2130OP *
2131newGVOP(type, flags, gv)
2132I32 type;
2133I32 flags;
2134GV *gv;
2135{
2136 GVOP *gvop;
2137 Newz(1101, gvop, 1, GVOP);
2138 gvop->op_type = type;
2139 gvop->op_ppaddr = ppaddr[type];
8990e307 2140 gvop->op_gv = (GV*)SvREFCNT_inc(gv);
79072805
LW		 2141 gvop->op_next = (OP*)gvop;
2142 gvop->op_flags = flags;
2143 if (opargs[type] & OA_RETSCALAR)
463ee0b2 2144 scalar((OP*)gvop);
79072805 2145 if (opargs[type] & OA_TARGET)
ed6116ce 2146 gvop->op_targ = pad_alloc(type, SVs_PADTMP);
e50aee73 2147 return CHECKOP(type, gvop);
79072805
LW		 2148}
2149
2150OP *
2151newPVOP(type, flags, pv)
2152I32 type;
2153I32 flags;
2154char *pv;
2155{
2156 PVOP *pvop;
2157 Newz(1101, pvop, 1, PVOP);
2158 pvop->op_type = type;
2159 pvop->op_ppaddr = ppaddr[type];
2160 pvop->op_pv = pv;
2161 pvop->op_next = (OP*)pvop;
2162 pvop->op_flags = flags;
2163 if (opargs[type] & OA_RETSCALAR)
463ee0b2 2164 scalar((OP*)pvop);
79072805 2165 if (opargs[type] & OA_TARGET)
ed6116ce 2166 pvop->op_targ = pad_alloc(type, SVs_PADTMP);
e50aee73 2167 return CHECKOP(type, pvop);
79072805
LW		 2168}
2169
79072805
LW		 2170void
2171package(op)
2172OP *op;
2173{
93a17b20 2174 SV *sv;
79072805
LW		 2175
2176 save_hptr(&curstash);
2177 save_item(curstname);
93a17b20 2178 if (op) {
463ee0b2
LW		 2179 STRLEN len;
2180 char *name;
93a17b20 2181 sv = cSVOP->op_sv;
463ee0b2 2182 name = SvPV(sv, len);
b1cb66bf 2183 curstash = gv_stashpvn(name,len,TRUE);
463ee0b2 2184 sv_setpvn(curstname, name, len);
93a17b20
LW		 2185 op_free(op);
2186 }
2187 else {
2188 sv_setpv(curstname,"<none>");
2189 curstash = Nullhv;
2190 }
79072805 2191 copline = NOLINE;
8990e307 2192 expect = XSTATE;
79072805
LW		 2193}
2194
85e6fe83 2195void
b1cb66bf 2196utilize(aver, floor, version, id, arg)
85e6fe83 2197int aver;
c07a80fd 2198I32 floor;
b1cb66bf 2199OP *version;
85e6fe83
LW		 2200OP *id;
2201OP *arg;
2202{
a0d0e21e
LW		 2203 OP *pack;
2204 OP *meth;
2205 OP *rqop;
2206 OP *imop;
b1cb66bf 2207 OP *veop;
85e6fe83 2208
a0d0e21e
LW		 2209 if (id->op_type != OP_CONST)
2210 croak("Module name must be constant");
85e6fe83 2211
b1cb66bf 2212 veop = Nullop;
2213
2214 if(version != Nullop) {
2215 SV *vesv = ((SVOP*)version)->op_sv;
2216
2217 if (arg == Nullop && !SvNIOK(vesv)) {
2218 arg = version;
2219 }
2220 else {
2221 OP *pack;
2222 OP *meth;
2223
2224 if (version->op_type != OP_CONST || !SvNIOK(vesv))
2225 croak("Version number must be constant number");
2226
2227 /* Make copy of id so we don't free it twice */
2228 pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv));
2229
2230 /* Fake up a method call to VERSION */
2231 meth = newSVOP(OP_CONST, 0, newSVpv("VERSION", 7));
2232 veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
2233 append_elem(OP_LIST,
2234 prepend_elem(OP_LIST, pack, list(version)),
2235 newUNOP(OP_METHOD, 0, meth)));
2236 }
2237 }
2238
a0d0e21e 2239 /* Fake up an import/unimport */
4633a7c4
LW		 2240 if (arg && arg->op_type == OP_STUB)
2241 imop = arg; /* no import on explicit () */
b1cb66bf 2242 else if(SvNIOK(((SVOP*)id)->op_sv)) {
2243 imop = Nullop; /* use 5.0; */
2244 }
4633a7c4
LW		 2245 else {
2246 /* Make copy of id so we don't free it twice */
2247 pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv));
4633a7c4
LW		 2248 meth = newSVOP(OP_CONST, 0,
2249 aver
2250 ? newSVpv("import", 6)
2251 : newSVpv("unimport", 8)
2252 );
2253 imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
a0d0e21e
LW		 2254 append_elem(OP_LIST,
2255 prepend_elem(OP_LIST, pack, list(arg)),
2256 newUNOP(OP_METHOD, 0, meth)));
4633a7c4
LW		 2257 }
2258
2259 /* Fake up a require */
2260 rqop = newUNOP(OP_REQUIRE, 0, id);
a0d0e21e
LW		 2261
2262 /* Fake up the BEGIN {}, which does its thing immediately. */
c07a80fd 2263 newSUB(floor,
a0d0e21e 2264 newSVOP(OP_CONST, 0, newSVpv("BEGIN", 5)),
4633a7c4 2265 Nullop,
a0d0e21e 2266 append_elem(OP_LINESEQ,
b1cb66bf 2267 append_elem(OP_LINESEQ,
2268 newSTATEOP(0, Nullch, rqop),
2269 newSTATEOP(0, Nullch, veop)),
a0d0e21e 2270 newSTATEOP(0, Nullch, imop) ));
85e6fe83 2271
85e6fe83
LW		 2272 copline = NOLINE;
2273 expect = XSTATE;
2274}
2275
79072805
LW		 2276OP *
2277newSLICEOP(flags, subscript, listval)
2278I32 flags;
2279OP *subscript;
2280OP *listval;
2281{
2282 return newBINOP(OP_LSLICE, flags,
8990e307
LW		 2283 list(force_list(subscript)),
2284 list(force_list(listval)) );
79072805
LW		 2285}
2286
2287static I32
2288list_assignment(op)
2289register OP *op;
2290{
2291 if (!op)
2292 return TRUE;
2293
2294 if (op->op_type == OP_NULL && op->op_flags & OPf_KIDS)
2295 op = cUNOP->op_first;
2296
2297 if (op->op_type == OP_COND_EXPR) {
2298 I32 t = list_assignment(cCONDOP->op_first->op_sibling);
2299 I32 f = list_assignment(cCONDOP->op_first->op_sibling->op_sibling);
2300
2301 if (t && f)
2302 return TRUE;
2303 if (t || f)
2304 yyerror("Assignment to both a list and a scalar");
2305 return FALSE;
2306 }
2307
2308 if (op->op_type == OP_LIST || op->op_flags & OPf_PARENS ||
2309 op->op_type == OP_RV2AV || op->op_type == OP_RV2HV ||
2310 op->op_type == OP_ASLICE || op->op_type == OP_HSLICE)
2311 return TRUE;
2312
93a17b20
LW		 2313 if (op->op_type == OP_PADAV || op->op_type == OP_PADHV)
2314 return TRUE;
2315
79072805
LW		 2316 if (op->op_type == OP_RV2SV)
2317 return FALSE;
2318
2319 return FALSE;
2320}
2321
2322OP *
a0d0e21e 2323newASSIGNOP(flags, left, optype, right)
79072805
LW		 2324I32 flags;
2325OP *left;
a0d0e21e 2326I32 optype;
79072805
LW		 2327OP *right;
2328{
2329 OP *op;
2330
a0d0e21e
LW		 2331 if (optype) {
2332 if (optype == OP_ANDASSIGN || optype == OP_ORASSIGN) {
2333 return newLOGOP(optype, 0,
2334 mod(scalar(left), optype),
2335 newUNOP(OP_SASSIGN, 0, scalar(right)));
2336 }
2337 else {
2338 return newBINOP(optype, OPf_STACKED,
2339 mod(scalar(left), optype), scalar(right));
2340 }
2341 }
2342
79072805 2343 if (list_assignment(left)) {
463ee0b2 2344 modcount = 0;
748a9306 2345 eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/
463ee0b2 2346 left = mod(left, OP_AASSIGN);
748a9306
LW		 2347 if (eval_start)
2348 eval_start = 0;
2349 else {
a0d0e21e
LW		 2350 op_free(left);
2351 op_free(right);
2352 return Nullop;
2353 }
79072805 2354 op = newBINOP(OP_AASSIGN, flags,
8990e307
LW		 2355 list(force_list(right)),
2356 list(force_list(left)) );
c07a80fd 2357 op->op_private = 0 | (flags >> 8);
a0d0e21e 2358 if (!(left->op_private & OPpLVAL_INTRO)) {
748a9306 2359 static int generation = 100;
79072805
LW		 2360 OP *curop;
2361 OP *lastop = op;
2362 generation++;
2363 for (curop = LINKLIST(op); curop != op; curop = LINKLIST(curop)) {
2364 if (opargs[curop->op_type] & OA_DANGEROUS) {
2365 if (curop->op_type == OP_GV) {
2366 GV *gv = ((GVOP*)curop)->op_gv;
2367 if (gv == defgv || SvCUR(gv) == generation)
2368 break;
2369 SvCUR(gv) = generation;
2370 }
748a9306
LW		 2371 else if (curop->op_type == OP_PADSV ||
2372 curop->op_type == OP_PADAV ||
2373 curop->op_type == OP_PADHV ||
2374 curop->op_type == OP_PADANY) {
2375 SV **svp = AvARRAY(comppad_name);
8e07c86e 2376 SV *sv = svp[curop->op_targ];
748a9306
LW		 2377 if (SvCUR(sv) == generation)
2378 break;
2379 SvCUR(sv) = generation; /* (SvCUR not used any more) */
2380 }
79072805
LW		 2381 else if (curop->op_type == OP_RV2CV)
2382 break;
2383 else if (curop->op_type == OP_RV2SV ||
2384 curop->op_type == OP_RV2AV ||
2385 curop->op_type == OP_RV2HV ||
2386 curop->op_type == OP_RV2GV) {
2387 if (lastop->op_type != OP_GV) /* funny deref? */
2388 break;
2389 }
2390 else
2391 break;
2392 }
2393 lastop = curop;
2394 }
2395 if (curop != op)
2396 op->op_private = OPpASSIGN_COMMON;
2397 }
c07a80fd 2398 if (right && right->op_type == OP_SPLIT) {
2399 OP* tmpop;
2400 if ((tmpop = ((LISTOP*)right)->op_first) &&
2401 tmpop->op_type == OP_PUSHRE)
2402 {
2403 PMOP *pm = (PMOP*)tmpop;
2404 if (left->op_type == OP_RV2AV &&
2405 !(left->op_private & OPpLVAL_INTRO) &&
2406 !(op->op_private & OPpASSIGN_COMMON) )
2407 {
2408 tmpop = ((UNOP*)left)->op_first;
2409 if (tmpop->op_type == OP_GV && !pm->op_pmreplroot) {
2410 pm->op_pmreplroot = (OP*)((GVOP*)tmpop)->op_gv;
2411 pm->op_pmflags |= PMf_ONCE;
2412 tmpop = ((UNOP*)op)->op_first; /* to list (nulled) */
2413 tmpop = ((UNOP*)tmpop)->op_first; /* to pushmark */
2414 tmpop->op_sibling = Nullop; /* don't free split */
2415 right->op_next = tmpop->op_next; /* fix starting loc */
2416 op_free(op); /* blow off assign */
54310121 2417 right->op_flags &= ~OPf_WANT;
a5f75d66 2418 /* "I don't know and I don't care." */
c07a80fd 2419 return right;
2420 }
2421 }
2422 else {
2423 if (modcount < 10000 &&
2424 ((LISTOP*)right)->op_last->op_type == OP_CONST)
2425 {
2426 SV *sv = ((SVOP*)((LISTOP*)right)->op_last)->op_sv;
2427 if (SvIVX(sv) == 0)
2428 sv_setiv(sv, modcount+1);
2429 }
2430 }
2431 }
2432 }
79072805
LW		 2433 return op;
2434 }
2435 if (!right)
2436 right = newOP(OP_UNDEF, 0);
2437 if (right->op_type == OP_READLINE) {
2438 right->op_flags |= OPf_STACKED;
463ee0b2 2439 return newBINOP(OP_NULL, flags, mod(scalar(left), OP_SASSIGN), scalar(right));
79072805 2440 }
a0d0e21e 2441 else {
748a9306 2442 eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/
79072805 2443 op = newBINOP(OP_SASSIGN, flags,
463ee0b2 2444 scalar(right), mod(scalar(left), OP_SASSIGN) );
748a9306
LW		 2445 if (eval_start)
2446 eval_start = 0;
2447 else {
a0d0e21e
LW		 2448 op_free(op);
2449 return Nullop;
2450 }
2451 }
79072805
LW		 2452 return op;
2453}
2454
2455OP *
2456newSTATEOP(flags, label, op)
2457I32 flags;
2458char *label;
2459OP *op;
2460{
bbce6d69 2461 U32 seq = intro_my();
79072805
LW		 2462 register COP *cop;
2463
2464 Newz(1101, cop, 1, COP);
8990e307
LW		 2465 if (perldb && curcop->cop_line && curstash != debstash) {
2466 cop->op_type = OP_DBSTATE;
2467 cop->op_ppaddr = ppaddr[ OP_DBSTATE ];
2468 }
2469 else {
2470 cop->op_type = OP_NEXTSTATE;
2471 cop->op_ppaddr = ppaddr[ OP_NEXTSTATE ];
2472 }
79072805 2473 cop->op_flags = flags;
c07a80fd 2474 cop->op_private = 0 | (flags >> 8);
ff0cee69 2475#ifdef NATIVE_HINTS
2476 cop->op_private |= NATIVE_HINTS;
2477#endif
79072805
LW		 2478 cop->op_next = (OP*)cop;
2479
463ee0b2
LW		 2480 if (label) {
2481 cop->cop_label = label;
85e6fe83 2482 hints |= HINT_BLOCK_SCOPE;
463ee0b2 2483 }
bbce6d69 2484 cop->cop_seq = seq;
a0d0e21e 2485 cop->cop_arybase = curcop->cop_arybase;
79072805
LW		 2486
2487 if (copline == NOLINE)
2488 cop->cop_line = curcop->cop_line;
2489 else {
2490 cop->cop_line = copline;
2491 copline = NOLINE;
2492 }
44a8e56a 2493 cop->cop_filegv = (GV*)SvREFCNT_inc(curcop->cop_filegv);
79072805
LW		 2494 cop->cop_stash = curstash;
2495
8990e307 2496 if (perldb && curstash != debstash) {
93a17b20
LW		 2497 SV **svp = av_fetch(GvAV(curcop->cop_filegv),(I32)cop->cop_line, FALSE);
2498 if (svp && *svp != &sv_undef && !SvIOK(*svp)) {
a0d0e21e 2499 (void)SvIOK_on(*svp);
a5f75d66 2500 SvIVX(*svp) = 1;
93a17b20
LW		 2501 SvSTASH(*svp) = (HV*)cop;
2502 }
2503 }
2504
79072805
LW		 2505 return prepend_elem(OP_LINESEQ, (OP*)cop, op);
2506}
2507
bbce6d69 2508/* "Introduce" my variables to visible status. */
2509U32
2510intro_my()
2511{
2512 SV **svp;
2513 SV *sv;
2514 I32 i;
2515
2516 if (! min_intro_pending)
2517 return cop_seqmax;
2518
2519 svp = AvARRAY(comppad_name);
2520 for (i = min_intro_pending; i <= max_intro_pending; i++) {
2521 if ((sv = svp[i]) && sv != &sv_undef && !SvIVX(sv)) {
2522 SvIVX(sv) = 999999999; /* Don't know scope end yet. */
2523 SvNVX(sv) = (double)cop_seqmax;
2524 }
2525 }
2526 min_intro_pending = 0;
2527 comppad_name_fill = max_intro_pending; /* Needn't search higher */
2528 return cop_seqmax++;
2529}
2530
79072805
LW		 2531OP *
2532newLOGOP(type, flags, first, other)
2533I32 type;
2534I32 flags;
2535OP* first;
2536OP* other;
2537{
2538 LOGOP *logop;
2539 OP *op;
2540
a0d0e21e
LW		 2541 if (type == OP_XOR) /* Not short circuit, but here by precedence. */
2542 return newBINOP(type, flags, scalar(first), scalar(other));
2543
8990e307 2544 scalarboolean(first);
79072805
LW		 2545 /* optimize "!a && b" to "a || b", and "!a || b" to "a && b" */
2546 if (first->op_type == OP_NOT && (first->op_flags & OPf_SPECIAL)) {
2547 if (type == OP_AND || type == OP_OR) {
2548 if (type == OP_AND)
2549 type = OP_OR;
2550 else
2551 type = OP_AND;
2552 op = first;
2553 first = cUNOP->op_first;
2554 if (op->op_next)
2555 first->op_next = op->op_next;
2556 cUNOP->op_first = Nullop;
2557 op_free(op);
2558 }
2559 }
2560 if (first->op_type == OP_CONST) {
93a17b20 2561 if (dowarn && (first->op_private & OPpCONST_BARE))
c07a80fd 2562 warn("Probable precedence problem on %s", op_desc[type]);
79072805
LW		 2563 if ((type == OP_AND) == (SvTRUE(((SVOP*)first)->op_sv))) {
2564 op_free(first);
2565 return other;
2566 }
2567 else {
2568 op_free(other);
2569 return first;
2570 }
2571 }
2572 else if (first->op_type == OP_WANTARRAY) {
2573 if (type == OP_AND)
2574 list(other);
2575 else
2576 scalar(other);
2577 }
a6006777 2578 else if (dowarn && (first->op_flags & OPf_KIDS)) {
2579 OP *k1 = ((UNOP*)first)->op_first;
2580 OP *k2 = k1->op_sibling;
2581 OPCODE warnop = 0;
2582 switch (first->op_type)
2583 {
2584 case OP_NULL:
2585 if (k2 && k2->op_type == OP_READLINE
2586 && (k2->op_flags & OPf_STACKED)
2587 && (k1->op_type == OP_RV2SV || k1->op_type == OP_PADSV))
2588 warnop = k2->op_type;
2589 break;
2590
2591 case OP_SASSIGN:
68dc0745 2592 if (k1->op_type == OP_READDIR
2593 || k1->op_type == OP_GLOB
2594 || k1->op_type == OP_EACH)
a6006777 2595 warnop = k1->op_type;
2596 break;
2597 }
8ebc5c01 2598 if (warnop) {
2599 line_t oldline = curcop->cop_line;
2600 curcop->cop_line = copline;
68dc0745 2601 warn("Value of %s%s can be \"0\"; test with defined()",
2602 op_desc[warnop],
2603 ((warnop == OP_READLINE || warnop == OP_GLOB)
2604 ? " construct" : "() operator"));
2605 curcop->cop_line = oldline;
8ebc5c01 2606 }
a6006777 2607 }
79072805
LW		 2608
2609 if (!other)
2610 return first;
2611
a0d0e21e
LW		 2612 if (type == OP_ANDASSIGN || type == OP_ORASSIGN)
2613 other->op_private |= OPpASSIGN_BACKWARDS; /* other is an OP_SASSIGN */
2614
79072805
LW		 2615 Newz(1101, logop, 1, LOGOP);
2616
2617 logop->op_type = type;
2618 logop->op_ppaddr = ppaddr[type];
2619 logop->op_first = first;
2620 logop->op_flags = flags | OPf_KIDS;
2621 logop->op_other = LINKLIST(other);
c07a80fd 2622 logop->op_private = 1 | (flags >> 8);
79072805
LW		 2623
2624 /* establish postfix order */
2625 logop->op_next = LINKLIST(first);
2626 first->op_next = (OP*)logop;
2627 first->op_sibling = other;
2628
2629 op = newUNOP(OP_NULL, 0, (OP*)logop);
2630 other->op_next = op;
2631
2632 return op;
2633}
2634
2635OP *
b1cb66bf 2636newCONDOP(flags, first, trueop, falseop)
79072805
LW		 2637I32 flags;
2638OP* first;
b1cb66bf 2639OP* trueop;
2640OP* falseop;
79072805
LW		 2641{
2642 CONDOP *condop;
2643 OP *op;
2644
b1cb66bf 2645 if (!falseop)
2646 return newLOGOP(OP_AND, 0, first, trueop);
2647 if (!trueop)
2648 return newLOGOP(OP_OR, 0, first, falseop);
79072805 2649
8990e307 2650 scalarboolean(first);
79072805
LW		 2651 if (first->op_type == OP_CONST) {
2652 if (SvTRUE(((SVOP*)first)->op_sv)) {
2653 op_free(first);
b1cb66bf 2654 op_free(falseop);
2655 return trueop;
79072805
LW		 2656 }
2657 else {
2658 op_free(first);
b1cb66bf 2659 op_free(trueop);
2660 return falseop;
79072805
LW		 2661 }
2662 }
2663 else if (first->op_type == OP_WANTARRAY) {
b1cb66bf 2664 list(trueop);
2665 scalar(falseop);
79072805
LW		 2666 }
2667 Newz(1101, condop, 1, CONDOP);
2668
2669 condop->op_type = OP_COND_EXPR;
2670 condop->op_ppaddr = ppaddr[OP_COND_EXPR];
2671 condop->op_first = first;
2672 condop->op_flags = flags | OPf_KIDS;
b1cb66bf 2673 condop->op_true = LINKLIST(trueop);
2674 condop->op_false = LINKLIST(falseop);
c07a80fd 2675 condop->op_private = 1 | (flags >> 8);
79072805
LW		 2676
2677 /* establish postfix order */
2678 condop->op_next = LINKLIST(first);
2679 first->op_next = (OP*)condop;
2680
b1cb66bf 2681 first->op_sibling = trueop;
2682 trueop->op_sibling = falseop;
79072805
LW		 2683 op = newUNOP(OP_NULL, 0, (OP*)condop);
2684
b1cb66bf 2685 trueop->op_next = op;
2686 falseop->op_next = op;
79072805
LW		 2687
2688 return op;
2689}
2690
2691OP *
2692newRANGE(flags, left, right)
2693I32 flags;
2694OP *left;
2695OP *right;
2696{
2697 CONDOP *condop;
2698 OP *flip;
2699 OP *flop;
2700 OP *op;
2701
2702 Newz(1101, condop, 1, CONDOP);
2703
2704 condop->op_type = OP_RANGE;
2705 condop->op_ppaddr = ppaddr[OP_RANGE];
2706 condop->op_first = left;
2707 condop->op_flags = OPf_KIDS;
2708 condop->op_true = LINKLIST(left);
2709 condop->op_false = LINKLIST(right);
c07a80fd 2710 condop->op_private = 1 | (flags >> 8);
79072805
LW		 2711
2712 left->op_sibling = right;
2713
2714 condop->op_next = (OP*)condop;
2715 flip = newUNOP(OP_FLIP, flags, (OP*)condop);
2716 flop = newUNOP(OP_FLOP, 0, flip);
2717 op = newUNOP(OP_NULL, 0, flop);
2718 linklist(flop);
2719
2720 left->op_next = flip;
2721 right->op_next = flop;
2722
ed6116ce 2723 condop->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
79072805 2724 sv_upgrade(PAD_SV(condop->op_targ), SVt_PVNV);
ed6116ce 2725 flip->op_targ = pad_alloc(OP_RANGE, SVs_PADMY);
79072805
LW		 2726 sv_upgrade(PAD_SV(flip->op_targ), SVt_PVNV);
2727
2728 flip->op_private = left->op_type == OP_CONST ? OPpFLIP_LINENUM : 0;
2729 flop->op_private = right->op_type == OP_CONST ? OPpFLIP_LINENUM : 0;
2730
2731 flip->op_next = op;
2732 if (!flip->op_private || !flop->op_private)
2733 linklist(op); /* blow off optimizer unless constant */
2734
2735 return op;
2736}
2737
2738OP *
2739newLOOPOP(flags, debuggable, expr, block)
2740I32 flags;
2741I32 debuggable;
2742OP *expr;
2743OP *block;
2744{
463ee0b2 2745 OP* listop;
93a17b20 2746 OP* op;
463ee0b2 2747 int once = block && block->op_flags & OPf_SPECIAL &&
a0d0e21e 2748 (block->op_type == OP_ENTERSUB || block->op_type == OP_NULL);
93a17b20 2749
463ee0b2
LW		 2750 if (expr) {
2751 if (once && expr->op_type == OP_CONST && !SvTRUE(((SVOP*)expr)->op_sv))
2752 return block; /* do {} while 0 does once */
774d564b 2753 if (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB) {
2754 expr = newUNOP(OP_DEFINED, 0,
2755 newASSIGNOP(0, newSVREF(newGVOP(OP_GV, 0, defgv)), 0, expr) );
2756 }
463ee0b2 2757 }
93a17b20 2758
8990e307 2759 listop = append_elem(OP_LINESEQ, block, newOP(OP_UNSTACK, 0));
93a17b20 2760 op = newLOGOP(OP_AND, 0, expr, listop);
463ee0b2 2761
79072805
LW		 2762 ((LISTOP*)listop)->op_last->op_next = LINKLIST(op);
2763
463ee0b2 2764 if (once && op != listop)
79072805
LW		 2765 op->op_next = ((LOGOP*)cUNOP->op_first)->op_other;
2766
748a9306
LW		 2767 if (op == listop)
2768 op = newUNOP(OP_NULL, 0, op); /* or do {} while 1 loses outer block */
2769
79072805 2770 op->op_flags |= flags;
a0d0e21e 2771 op = scope(op);
748a9306 2772 op->op_flags |= OPf_SPECIAL; /* suppress POPBLOCK curpm restoration*/
a0d0e21e 2773 return op;
79072805
LW		 2774}
2775
2776OP *
2777newWHILEOP(flags, debuggable, loop, expr, block, cont)
2778I32 flags;
2779I32 debuggable;
2780LOOP *loop;
2781OP *expr;
2782OP *block;
2783OP *cont;
2784{
2785 OP *redo;
2786 OP *next = 0;
2787 OP *listop;
2788 OP *op;
2789 OP *condop;
2790
748a9306
LW		 2791 if (expr && (expr->op_type == OP_READLINE || expr->op_type == OP_GLOB)) {
2792 expr = newUNOP(OP_DEFINED, 0,
2793 newASSIGNOP(0, newSVREF(newGVOP(OP_GV, 0, defgv)), 0, expr) );
2794 }
79072805
LW		 2795
2796 if (!block)
2797 block = newOP(OP_NULL, 0);
2798
2799 if (cont)
2800 next = LINKLIST(cont);
2801 if (expr)
2802 cont = append_elem(OP_LINESEQ, cont, newOP(OP_UNSTACK, 0));
2803
463ee0b2 2804 listop = append_list(OP_LINESEQ, (LISTOP*)block, (LISTOP*)cont);
79072805
LW		 2805 redo = LINKLIST(listop);
2806
2807 if (expr) {
2808 op = newLOGOP(OP_AND, 0, expr, scalar(listop));
85e6fe83
LW		 2809 if (op == expr && op->op_type == OP_CONST && !SvTRUE(cSVOP->op_sv)) {
2810 op_free(expr); /* oops, it's a while (0) */
463ee0b2
LW		 2811 op_free((OP*)loop);
2812 return Nullop; /* (listop already freed by newLOGOP) */
2813 }
79072805
LW		 2814 ((LISTOP*)listop)->op_last->op_next = condop =
2815 (op == listop ? redo : LINKLIST(op));
2816 if (!next)
2817 next = condop;
2818 }
2819 else
2820 op = listop;
2821
2822 if (!loop) {
2823 Newz(1101,loop,1,LOOP);
2824 loop->op_type = OP_ENTERLOOP;
2825 loop->op_ppaddr = ppaddr[OP_ENTERLOOP];
2826 loop->op_private = 0;
2827 loop->op_next = (OP*)loop;
2828 }
2829
463ee0b2 2830 op = newBINOP(OP_LEAVELOOP, 0, (OP*)loop, op);
79072805
LW		 2831
2832 loop->op_redoop = redo;
2833 loop->op_lastop = op;
2834
2835 if (next)
2836 loop->op_nextop = next;
2837 else
2838 loop->op_nextop = op;
2839
2840 op->op_flags |= flags;
c07a80fd 2841 op->op_private |= (flags >> 8);
79072805
LW		 2842 return op;
2843}
2844
2845OP *
a0d0e21e 2846#ifndef CAN_PROTOTYPE
79072805
LW		 2847newFOROP(flags,label,forline,sv,expr,block,cont)
2848I32 flags;
2849char *label;
2850line_t forline;
2851OP* sv;
2852OP* expr;
2853OP*block;
2854OP*cont;
8990e307
LW		 2855#else
2856newFOROP(I32 flags,char *label,line_t forline,OP *sv,OP *expr,OP *block,OP *cont)
a0d0e21e 2857#endif /* CAN_PROTOTYPE */
79072805
LW		 2858{
2859 LOOP *loop;
85e6fe83 2860 int padoff = 0;
4633a7c4 2861 I32 iterflags = 0;
79072805
LW		 2862
2863 copline = forline;
2864 if (sv) {
85e6fe83 2865 if (sv->op_type == OP_RV2SV) { /* symbol table variable */
748a9306
LW		 2866 sv->op_type = OP_RV2GV;
2867 sv->op_ppaddr = ppaddr[OP_RV2GV];
79072805 2868 }
85e6fe83
LW		 2869 else if (sv->op_type == OP_PADSV) { /* private variable */
2870 padoff = sv->op_targ;
2871 op_free(sv);
2872 sv = Nullop;
2873 }
79072805 2874 else
c07a80fd 2875 croak("Can't use %s for loop variable", op_desc[sv->op_type]);
79072805
LW		 2876 }
2877 else {
2878 sv = newGVOP(OP_GV, 0, defgv);
2879 }
5f05dabc 2880 if (expr->op_type == OP_RV2AV || expr->op_type == OP_PADAV) {
4633a7c4
LW		 2881 expr = scalar(ref(expr, OP_ITER));
2882 iterflags |= OPf_STACKED;
2883 }
2884 loop = (LOOP*)list(convert(OP_ENTERITER, iterflags,
a0d0e21e
LW		 2885 append_elem(OP_LIST, mod(force_list(expr), OP_GREPSTART),
2886 scalar(sv))));
85e6fe83
LW		 2887 assert(!loop->op_next);
2888 Renew(loop, 1, LOOP);
2889 loop->op_targ = padoff;
2890 return newSTATEOP(0, label, newWHILEOP(flags, 1, loop,
2891 newOP(OP_ITER, 0), block, cont));
79072805
LW		 2892}
2893
8990e307
LW		 2894OP*
2895newLOOPEX(type, label)
2896I32 type;
2897OP* label;
2898{
2899 OP *op;
2900 if (type != OP_GOTO || label->op_type == OP_CONST) {
a0d0e21e
LW		 2901 op = newPVOP(type, 0, savepv(
2902 label->op_type == OP_CONST
2903 ? SvPVx(((SVOP*)label)->op_sv, na)
2904 : "" ));
8990e307
LW		 2905 op_free(label);
2906 }
2907 else {
a0d0e21e
LW		 2908 if (label->op_type == OP_ENTERSUB)
2909 label = newUNOP(OP_REFGEN, 0, mod(label, OP_REFGEN));
8990e307
LW		 2910 op = newUNOP(type, OPf_STACKED, label);
2911 }
85e6fe83 2912 hints |= HINT_BLOCK_SCOPE;
8990e307
LW		 2913 return op;
2914}
2915
79072805 2916void
85e6fe83 2917cv_undef(cv)
79072805
LW		 2918CV *cv;
2919{
a0d0e21e
LW		 2920 if (!CvXSUB(cv) && CvROOT(cv)) {
2921 if (CvDEPTH(cv))
2922 croak("Can't undef active subroutine");
8990e307 2923 ENTER;
a0d0e21e
LW		 2924
2925 SAVESPTR(curpad);
2926 curpad = 0;
2927
a5f75d66 2928 if (!CvCLONED(cv))
748a9306 2929 op_free(CvROOT(cv));
79072805 2930 CvROOT(cv) = Nullop;
8990e307 2931 LEAVE;
79072805 2932 }
44a8e56a 2933 CvFLAGS(cv) = 0;
8e07c86e
AD		 2934 SvREFCNT_dec(CvGV(cv));
2935 CvGV(cv) = Nullgv;
2936 SvREFCNT_dec(CvOUTSIDE(cv));
2937 CvOUTSIDE(cv) = Nullcv;
2938 if (CvPADLIST(cv)) {
8ebc5c01 2939 /* may be during global destruction */
2940 if (SvREFCNT(CvPADLIST(cv))) {
2941 I32 i = AvFILL(CvPADLIST(cv));
2942 while (i >= 0) {
2943 SV** svp = av_fetch(CvPADLIST(cv), i--, FALSE);
46fc3d4c 2944 SV* sv = svp ? *svp : Nullsv;
2945 if (!sv)
2946 continue;
2947 if (sv == (SV*)comppad_name)
2948 comppad_name = Nullav;
2949 else if (sv == (SV*)comppad) {
2950 comppad = Nullav;
2951 curpad = Null(SV**);
2952 }
2953 SvREFCNT_dec(sv);
8ebc5c01 2954 }
2955 SvREFCNT_dec((SV*)CvPADLIST(cv));
8e07c86e 2956 }
8e07c86e
AD		 2957 CvPADLIST(cv) = Nullav;
2958 }
79072805
LW		 2959}
2960
5f05dabc 2961#ifdef DEBUG_CLOSURES
2962static void
2963cv_dump(cv)
2964CV* cv;
2965{
2966 CV *outside = CvOUTSIDE(cv);
2967 AV* padlist = CvPADLIST(cv);
4fdae800 2968 AV* pad_name;
2969 AV* pad;
2970 SV** pname;
2971 SV** ppad;
5f05dabc 2972 I32 ix;
2973
2974 PerlIO_printf(Perl_debug_log, "\tCV=0x%p (%s), OUTSIDE=0x%p (%s)\n",
ab50184a
CS		 2975 cv,
2976 (CvANON(cv) ? "ANON"
2977 : (cv == main_cv) ? "MAIN"
07055b4c 2978 : CvUNIQUE(outside) ? "UNIQUE"
44a8e56a 2979 : CvGV(cv) ? GvNAME(CvGV(cv)) : "UNDEFINED"),
ab50184a
CS		 2980 outside,
2981 (!outside ? "null"
2982 : CvANON(outside) ? "ANON"
2983 : (outside == main_cv) ? "MAIN"
07055b4c 2984 : CvUNIQUE(outside) ? "UNIQUE"
44a8e56a 2985 : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
5f05dabc 2986
4fdae800 2987 if (!padlist)
2988 return;
2989
2990 pad_name = (AV*)*av_fetch(padlist, 0, FALSE);
2991 pad = (AV*)*av_fetch(padlist, 1, FALSE);
2992 pname = AvARRAY(pad_name);
2993 ppad = AvARRAY(pad);
2994
9607fc9c 2995 for (ix = 1; ix <= AvFILL(pad_name); ix++) {
5f05dabc 2996 if (SvPOK(pname[ix]))
4fdae800 2997 PerlIO_printf(Perl_debug_log, "\t%4d. 0x%p (%s\"%s\" %ld-%ld)\n",
2998 ix, ppad[ix],
2999 SvFAKE(pname[ix]) ? "FAKE " : "",
3000 SvPVX(pname[ix]),
ab50184a
CS		 3001 (long)I_32(SvNVX(pname[ix])),
3002 (long)SvIVX(pname[ix]));
5f05dabc 3003 }
3004}
3005#endif /* DEBUG_CLOSURES */
3006
3007static CV *
3008cv_clone2(proto, outside)
748a9306 3009CV* proto;
5f05dabc 3010CV* outside;
748a9306
LW		 3011{
3012 AV* av;
3013 I32 ix;
3014 AV* protopadlist = CvPADLIST(proto);
3015 AV* protopad_name = (AV*)*av_fetch(protopadlist, 0, FALSE);
3016 AV* protopad = (AV*)*av_fetch(protopadlist, 1, FALSE);
5f05dabc 3017 SV** pname = AvARRAY(protopad_name);
3018 SV** ppad = AvARRAY(protopad);
9607fc9c 3019 I32 fname = AvFILL(protopad_name);
3020 I32 fpad = AvFILL(protopad);
748a9306
LW		 3021 AV* comppadlist;
3022 CV* cv;
3023
07055b4c
CS		 3024 assert(!CvUNIQUE(proto));
3025
748a9306
LW		 3026 ENTER;
3027 SAVESPTR(curpad);
3028 SAVESPTR(comppad);
46fc3d4c 3029 SAVESPTR(comppad_name);
748a9306
LW		 3030 SAVESPTR(compcv);
3031
3032 cv = compcv = (CV*)NEWSV(1104,0);
fa83b5b6 3033 sv_upgrade((SV *)cv, SvTYPE(proto));
a5f75d66 3034 CvCLONED_on(cv);
5f05dabc 3035 if (CvANON(proto))
3036 CvANON_on(cv);
748a9306
LW		 3037
3038 CvFILEGV(cv) = CvFILEGV(proto);
44a8e56a 3039 CvGV(cv) = (GV*)SvREFCNT_inc(CvGV(proto));
748a9306
LW		 3040 CvSTASH(cv) = CvSTASH(proto);
3041 CvROOT(cv) = CvROOT(proto);
3042 CvSTART(cv) = CvSTART(proto);
5f05dabc 3043 if (outside)
3044 CvOUTSIDE(cv) = (CV*)SvREFCNT_inc(outside);
748a9306 3045
68dc0745 3046 if (SvPOK(proto))
3047 sv_setpvn((SV*)cv, SvPVX(proto), SvCUR(proto));
3048
46fc3d4c 3049 comppad_name = newAV();
3050 for (ix = fname; ix >= 0; ix--)
3051 av_store(comppad_name, ix, SvREFCNT_inc(pname[ix]));
3052
748a9306
LW		 3053 comppad = newAV();
3054
3055 comppadlist = newAV();
3056 AvREAL_off(comppadlist);
46fc3d4c 3057 av_store(comppadlist, 0, (SV*)comppad_name);
b355b4e0 3058 av_store(comppadlist, 1, (SV*)comppad);
748a9306 3059 CvPADLIST(cv) = comppadlist;
5f05dabc 3060 av_fill(comppad, AvFILL(protopad));
748a9306
LW		 3061 curpad = AvARRAY(comppad);
3062
3063 av = newAV(); /* will be @_ */
3064 av_extend(av, 0);
3065 av_store(comppad, 0, (SV*)av);
3066 AvFLAGS(av) = AVf_REIFY;
3067
9607fc9c 3068 for (ix = fpad; ix > 0; ix--) {
3069 SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
aa689395 3070 if (namesv && namesv != &sv_undef) {
3071 char *name = SvPVX(namesv); /* XXX */
3072 if (SvFLAGS(namesv) & SVf_FAKE) { /* lexical from outside? */
3073 I32 off = pad_findlex(name, ix, SvIVX(namesv),
5f05dabc 3074 CvOUTSIDE(cv), cxstack_ix);
3075 if (!off)
3076 curpad[ix] = SvREFCNT_inc(ppad[ix]);
3077 else if (off != ix)
748a9306
LW		 3078 croak("panic: cv_clone: %s", name);
3079 }
3080 else { /* our own lexical */
aa689395 3081 SV* sv;
5f05dabc 3082 if (*name == '&') {
3083 /* anon code -- we'll come back for it */
3084 sv = SvREFCNT_inc(ppad[ix]);
3085 }
3086 else if (*name == '@')
3087 sv = (SV*)newAV();
748a9306 3088 else if (*name == '%')
5f05dabc 3089 sv = (SV*)newHV();
748a9306 3090 else
5f05dabc 3091 sv = NEWSV(0,0);
3092 if (!SvPADBUSY(sv))
3093 SvPADMY_on(sv);
3094 curpad[ix] = sv;
748a9306
LW		 3095 }
3096 }
3097 else {
aa689395 3098 SV* sv = NEWSV(0,0);
748a9306 3099 SvPADTMP_on(sv);
5f05dabc 3100 curpad[ix] = sv;
748a9306
LW		 3101 }
3102 }
3103
5f05dabc 3104 /* Now that vars are all in place, clone nested closures. */
3105
9607fc9c 3106 for (ix = fpad; ix > 0; ix--) {
3107 SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
aa689395 3108 if (namesv
3109 && namesv != &sv_undef
3110 && !(SvFLAGS(namesv) & SVf_FAKE)
3111 && *SvPVX(namesv) == '&'
5f05dabc 3112 && CvCLONE(ppad[ix]))
3113 {
3114 CV *kid = cv_clone2((CV*)ppad[ix], cv);
3115 SvREFCNT_dec(ppad[ix]);
3116 CvCLONE_on(kid);
3117 SvPADMY_on(kid);
3118 curpad[ix] = (SV*)kid;
3119 }
3120 }
3121
3122#ifdef DEBUG_CLOSURES
ab50184a
CS		 3123 PerlIO_printf(Perl_debug_log, "Cloned inside:\n");
3124 cv_dump(outside);
3125 PerlIO_printf(Perl_debug_log, " from:\n");
5f05dabc 3126 cv_dump(proto);
ab50184a 3127 PerlIO_printf(Perl_debug_log, " to:\n");
5f05dabc 3128 cv_dump(cv);
3129#endif
3130
748a9306
LW		 3131 LEAVE;
3132 return cv;
3133}
3134
5f05dabc 3135CV *
3136cv_clone(proto)
3137CV* proto;
3138{
3139 return cv_clone2(proto, CvOUTSIDE(proto));
3140}
3141
3fe9a6f1 3142void
3143cv_ckproto(cv, gv, p)
3144CV* cv;
3145GV* gv;
3146char* p;
3147{
3148 if ((!p != !SvPOK(cv)) || (p && strNE(p, SvPVX(cv)))) {
46fc3d4c 3149 SV* msg = sv_newmortal();
3fe9a6f1 3150 SV* name = Nullsv;
3151
3152 if (gv)
46fc3d4c 3153 gv_efullname3(name = sv_newmortal(), gv, Nullch);
3154 sv_setpv(msg, "Prototype mismatch:");
3155 if (name)
fc36a67e 3156 sv_catpvf(msg, " sub %_", name);
3fe9a6f1 3157 if (SvPOK(cv))
46fc3d4c 3158 sv_catpvf(msg, " (%s)", SvPVX(cv));
3159 sv_catpv(msg, " vs ");
3160 if (p)
3161 sv_catpvf(msg, "(%s)", p);
3162 else
3163 sv_catpv(msg, "none");
fc36a67e 3164 warn("%_", msg);
3fe9a6f1 3165 }
3166}
3167
760ac839
LW		 3168SV *
3169cv_const_sv(cv)
3fe9a6f1 3170CV* cv;
760ac839
LW		 3171{
3172 OP *o;
54310121 3173 SV *sv;
760ac839 3174
54310121 3175 if (!cv || !SvPOK(cv) || SvCUR(cv))
3176 return Nullsv;
760ac839 3177
54310121 3178 sv = Nullsv;
3179 for (o = CvSTART(cv); o; o = o->op_next) {
3180 OPCODE type = o->op_type;
3181
3182 if (type == OP_NEXTSTATE || type == OP_NULL || type == OP_PUSHMARK)
3183 continue;
3184 if (type == OP_LEAVESUB || type == OP_RETURN)
3185 break;
3186 if (sv)
3187 return Nullsv;
3188 if (type == OP_CONST)
760ac839 3189 sv = ((SVOP*)o)->op_sv;
54310121 3190 else if (type == OP_PADSV) {
3191 AV* pad = (AV*)(AvARRAY(CvPADLIST(cv))[1]);
3192 sv = pad ? AvARRAY(pad)[o->op_targ] : Nullsv;
5aabfad6 3193 if (!sv || (!SvREADONLY(sv) && SvREFCNT(sv) > 1))
54310121 3194 return Nullsv;
760ac839 3195 }
54310121 3196 else
3197 return Nullsv;
760ac839 3198 }
5aabfad6 3199 if (sv)
3200 SvREADONLY_on(sv);
760ac839
LW		 3201 return sv;
3202}
3203
748a9306 3204CV *
4633a7c4 3205newSUB(floor,op,proto,block)
79072805
LW		 3206I32 floor;
3207OP *op;
4633a7c4 3208OP *proto;
79072805
LW		 3209OP *block;
3210{
44a8e56a 3211 char *name = op ? SvPVx(cSVOP->op_sv, na) : Nullch;
3212 GV *gv = gv_fetchpv(name ? name : "__ANON__", GV_ADDMULTI, SVt_PVCV);
3fe9a6f1 3213 char *ps = proto ? SvPVx(((SVOP*)proto)->op_sv, na) : Nullch;
79072805 3214 register CV *cv;
a0d0e21e 3215 I32 ix;
79072805 3216
44a8e56a 3217 if (op)
8ebc5c01 3218 SAVEFREEOP(op);
3fe9a6f1 3219 if (proto)
3220 SAVEFREEOP(proto);
3221
68dc0745 3222 if (!name || GvCVGEN(gv))
3223 cv = Nullcv;
3224 else if (cv = GvCV(gv)) {
3fe9a6f1 3225 cv_ckproto(cv, gv, ps);
68dc0745 3226 /* already defined (or promised)? */
3227 if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
3228 SV* const_sv;
aa689395 3229 if (!block) {
3230 /* just a "sub foo;" when &foo is already defined */
3231 SAVEFREESV(compcv);
3232 goto done;
3233 }
68dc0745 3234 const_sv = cv_const_sv(cv);
44a8e56a 3235 if (const_sv || dowarn) {
79072805 3236 line_t oldline = curcop->cop_line;
79072805 3237 curcop->cop_line = copline;
760ac839 3238 warn(const_sv ? "Constant subroutine %s redefined"
68dc0745 3239 : "Subroutine %s redefined", name);
79072805
LW		 3240 curcop->cop_line = oldline;
3241 }
8990e307 3242 SvREFCNT_dec(cv);
68dc0745 3243 cv = Nullcv;
79072805
LW		 3244 }
3245 }
a0d0e21e 3246 if (cv) { /* must reuse cv if autoloaded */
4633a7c4 3247 cv_undef(cv);
44a8e56a 3248 CvFLAGS(cv) = CvFLAGS(compcv);
748a9306 3249 CvOUTSIDE(cv) = CvOUTSIDE(compcv);
e9a444f0 3250 CvOUTSIDE(compcv) = 0;
748a9306 3251 CvPADLIST(cv) = CvPADLIST(compcv);
4aa0a1f7 3252 CvPADLIST(compcv) = 0;
4633a7c4
LW		 3253 if (SvREFCNT(compcv) > 1) /* XXX Make closures transit through stub. */
3254 CvOUTSIDE(compcv) = (CV*)SvREFCNT_inc((SV*)cv);
748a9306 3255 SvREFCNT_dec(compcv);
a0d0e21e
LW		 3256 }
3257 else {
748a9306 3258 cv = compcv;
44a8e56a 3259 if (name) {
3260 GvCV(gv) = cv;
3261 GvCVGEN(gv) = 0;
3262 sub_generation++;
3263 }
a0d0e21e 3264 }
44a8e56a 3265 CvGV(cv) = (GV*)SvREFCNT_inc(gv);
79072805 3266 CvFILEGV(cv) = curcop->cop_filegv;
8990e307
LW		 3267 CvSTASH(cv) = curstash;
3268
3fe9a6f1 3269 if (ps)
3270 sv_setpv((SV*)cv, ps);
4633a7c4 3271
c07a80fd 3272 if (error_count) {
3273 op_free(block);
3274 block = Nullop;
68dc0745 3275 if (name) {
3276 char *s = strrchr(name, ':');
3277 s = s ? s+1 : name;
6d4c2119
CS		 3278 if (strEQ(s, "BEGIN")) {
3279 char *not_safe =
3280 "BEGIN not safe after errors--compilation aborted";
3281 if (in_eval & 4)
3282 croak(not_safe);
3283 else {
3284 /* force display of errors found but not reported */
3285 sv_catpv(GvSV(errgv), not_safe);
3286 croak("%s", SvPVx(GvSV(errgv), na));
3287 }
3288 }
68dc0745 3289 }
c07a80fd 3290 }
a0d0e21e 3291 if (!block) {
a0d0e21e
LW		 3292 copline = NOLINE;
3293 LEAVE_SCOPE(floor);
3294 return cv;
3295 }
3296
54310121 3297 if (AvFILL(comppad_name) < AvFILL(comppad))
3298 av_store(comppad_name, AvFILL(comppad), Nullsv);
a0d0e21e 3299
54310121 3300 if (CvCLONE(cv)) {
3301 SV **namep = AvARRAY(comppad_name);
3302 for (ix = AvFILL(comppad); ix > 0; ix--) {
3303 SV *namesv;
3304
3305 if (SvIMMORTAL(curpad[ix]))
3306 continue;
3307 /*
3308 * The only things that a clonable function needs in its
3309 * pad are references to outer lexicals and anonymous subs.
3310 * The rest are created anew during cloning.
3311 */
3312 if (!((namesv = namep[ix]) != Nullsv &&
3313 namesv != &sv_undef &&
3314 (SvFAKE(namesv) ||
3315 *SvPVX(namesv) == '&')))
3316 {
3317 SvREFCNT_dec(curpad[ix]);
3318 curpad[ix] = Nullsv;
3319 }
3320 }
a0d0e21e 3321 }
54310121 3322 else {
3323 AV *av = newAV(); /* Will be @_ */
3324 av_extend(av, 0);
3325 av_store(comppad, 0, (SV*)av);
3326 AvFLAGS(av) = AVf_REIFY;
79072805 3327
54310121 3328 for (ix = AvFILL(comppad); ix > 0; ix--) {
3329 if (SvIMMORTAL(curpad[ix]))
3330 continue;
3331 if (!SvPADMY(curpad[ix]))
3332 SvPADTMP_on(curpad[ix]);
3333 }
3334 }
79072805 3335
a0d0e21e 3336 CvROOT(cv) = newUNOP(OP_LEAVESUB, 0, scalarseq(block));
79072805
LW		 3337 CvSTART(cv) = LINKLIST(CvROOT(cv));
3338 CvROOT(cv)->op_next = 0;
3339 peep(CvSTART(cv));
a6006777 3340
44a8e56a 3341 if (name) {
3342 char *s;
3343
3344 if (perldb && curstash != debstash) {
46fc3d4c 3345 SV *sv = NEWSV(0,0);
44a8e56a 3346 SV *tmpstr = sv_newmortal();
3347 static GV *db_postponed;
3348 CV *cv;
3349 HV *hv;
3350
fc36a67e 3351 sv_setpvf(sv, "%_:%ld-%ld",
46fc3d4c 3352 GvSV(curcop->cop_filegv),
3353 (long)subline, (long)curcop->cop_line);
44a8e56a 3354 gv_efullname3(tmpstr, gv, Nullch);
3355 hv_store(GvHV(DBsub), SvPVX(tmpstr), SvCUR(tmpstr), sv, 0);
3356 if (!db_postponed) {
6bbcb22c 3357 db_postponed = gv_fetchpv("DB::postponed", GV_ADDMULTI, SVt_PVHV);
44a8e56a 3358 }
3359 hv = GvHVn(db_postponed);
9607fc9c 3360 if (HvFILL(hv) > 0 && hv_exists(hv, SvPVX(tmpstr), SvCUR(tmpstr))
3361 && (cv = GvCV(db_postponed))) {
44a8e56a 3362 dSP;
3363 PUSHMARK(sp);
3364 XPUSHs(tmpstr);
3365 PUTBACK;
3366 perl_call_sv((SV*)cv, G_DISCARD);
3367 }
3368 }
3369
3370 if ((s = strrchr(name,':')))
28757baa 3371 s++;
3372 else
3373 s = name;
68dc0745 3374 if (strEQ(s, "BEGIN")) {
2ae324a7 3375 I32 oldscope = scopestack_ix;
28757baa 3376 ENTER;
3377 SAVESPTR(compiling.cop_filegv);
3378 SAVEI16(compiling.cop_line);
3379 SAVEI32(perldb);
3380 save_svref(&rs);
3381 sv_setsv(rs, nrs);
3382
3383 if (!beginav)
3384 beginav = newAV();
3385 DEBUG_x( dump_sub(gv) );
3386 av_push(beginav, (SV *)cv);
3387 GvCV(gv) = 0;
68dc0745 3388 call_list(oldscope, beginav);
a6006777 3389
28757baa 3390 curcop = &compiling;
3391 LEAVE;
3392 }
3393 else if (strEQ(s, "END") && !error_count) {
3394 if (!endav)
3395 endav = newAV();
3396 av_unshift(endav, 1);
3397 av_store(endav, 0, (SV *)cv);
3398 GvCV(gv) = 0;
3399 }
93a17b20 3400 }
a6006777 3401
aa689395 3402 done:
a6006777 3403 copline = NOLINE;
3404 LEAVE_SCOPE(floor);
a0d0e21e 3405 return cv;
79072805
LW		 3406}
3407
a0d0e21e
LW		 3408#ifdef DEPRECATED
3409CV *
463ee0b2 3410newXSUB(name, ix, subaddr, filename)
79072805
LW		 3411char *name;
3412I32 ix;
3413I32 (*subaddr)();
3414char *filename;
3415{
a0d0e21e 3416 CV* cv = newXS(name, (void(*)())subaddr, filename);
a5f75d66 3417 CvOLDSTYLE_on(cv);
a0d0e21e
LW		 3418 CvXSUBANY(cv).any_i32 = ix;
3419 return cv;
3420}
3421#endif
3422
3423CV *
3424newXS(name, subaddr, filename)
3425char *name;
3426void (*subaddr) _((CV*));
3427char *filename;
3428{
44a8e56a 3429 GV *gv = gv_fetchpv(name ? name : "__ANON__", GV_ADDMULTI, SVt_PVCV);
79072805 3430 register CV *cv;
44a8e56a 3431
3432 if (cv = (name ? GvCV(gv) : Nullcv)) {
3433 if (GvCVGEN(gv)) {
3434 /* just a cached method */
3435 SvREFCNT_dec(cv);
3436 cv = 0;
3437 }
3438 else if (CvROOT(cv) || CvXSUB(cv) || GvASSUMECV(gv)) {
3439 /* already defined (or promised) */
a0d0e21e
LW		 3440 if (dowarn) {
3441 line_t oldline = curcop->cop_line;
a0d0e21e
LW		 3442 curcop->cop_line = copline;
3443 warn("Subroutine %s redefined",name);
3444 curcop->cop_line = oldline;
3445 }
3446 SvREFCNT_dec(cv);
3447 cv = 0;
79072805 3448 }
79072805 3449 }
44a8e56a 3450
3451 if (cv) /* must reuse cv if autoloaded */
3452 cv_undef(cv);
a0d0e21e
LW		 3453 else {
3454 cv = (CV*)NEWSV(1105,0);
3455 sv_upgrade((SV *)cv, SVt_PVCV);
44a8e56a 3456 if (name) {
3457 GvCV(gv) = cv;
3458 GvCVGEN(gv) = 0;
3459 sub_generation++;
3460 }
a0d0e21e 3461 }
44a8e56a 3462 CvGV(cv) = (GV*)SvREFCNT_inc(gv);
79072805 3463 CvFILEGV(cv) = gv_fetchfile(filename);
a0d0e21e 3464 CvXSUB(cv) = subaddr;
44a8e56a 3465
28757baa 3466 if (name) {
3467 char *s = strrchr(name,':');
3468 if (s)
3469 s++;
3470 else
3471 s = name;
3472 if (strEQ(s, "BEGIN")) {
3473 if (!beginav)
3474 beginav = newAV();
44a8e56a 3475 av_push(beginav, (SV *)cv);
3476 GvCV(gv) = 0;
28757baa 3477 }
3478 else if (strEQ(s, "END")) {
3479 if (!endav)
3480 endav = newAV();
3481 av_unshift(endav, 1);
44a8e56a 3482 av_store(endav, 0, (SV *)cv);
3483 GvCV(gv) = 0;
28757baa 3484 }
3485 }
44a8e56a 3486 else
a5f75d66 3487 CvANON_on(cv);
44a8e56a 3488
a0d0e21e 3489 return cv;
79072805
LW		 3490}
3491
3492void
3493newFORM(floor,op,block)
3494I32 floor;
3495OP *op;
3496OP *block;
3497{
3498 register CV *cv;
3499 char *name;
3500 GV *gv;
a0d0e21e 3501 I32 ix;
79072805
LW		 3502
3503 if (op)
463ee0b2 3504 name = SvPVx(cSVOP->op_sv, na);
79072805
LW		 3505 else
3506 name = "STDOUT";
85e6fe83 3507 gv = gv_fetchpv(name,TRUE, SVt_PVFM);
a5f75d66 3508 GvMULTI_on(gv);
79072805
LW		 3509 if (cv = GvFORM(gv)) {
3510 if (dowarn) {
3511 line_t oldline = curcop->cop_line;
3512
3513 curcop->cop_line = copline;
3514 warn("Format %s redefined",name);
3515 curcop->cop_line = oldline;
3516 }
8990e307 3517 SvREFCNT_dec(cv);
79072805 3518 }
748a9306 3519 cv = compcv;
79072805 3520 GvFORM(gv) = cv;
44a8e56a 3521 CvGV(cv) = (GV*)SvREFCNT_inc(gv);
79072805
LW		 3522 CvFILEGV(cv) = curcop->cop_filegv;
3523
a0d0e21e 3524 for (ix = AvFILL(comppad); ix > 0; ix--) {
44a8e56a 3525 if (!SvPADMY(curpad[ix]) && !SvIMMORTAL(curpad[ix]))
a0d0e21e
LW		 3526 SvPADTMP_on(curpad[ix]);
3527 }
3528
79072805
LW		 3529 CvROOT(cv) = newUNOP(OP_LEAVEWRITE, 0, scalarseq(block));
3530 CvSTART(cv) = LINKLIST(CvROOT(cv));
3531 CvROOT(cv)->op_next = 0;
3532 peep(CvSTART(cv));
79072805
LW		 3533 op_free(op);
3534 copline = NOLINE;
8990e307 3535 LEAVE_SCOPE(floor);
79072805
LW		 3536}
3537
3538OP *
79072805
LW		 3539newANONLIST(op)
3540OP* op;
3541{
93a17b20 3542 return newUNOP(OP_REFGEN, 0,
a0d0e21e 3543 mod(list(convert(OP_ANONLIST, 0, op)), OP_REFGEN));
79072805
LW		 3544}
3545
3546OP *
3547newANONHASH(op)
3548OP* op;
3549{
93a17b20 3550 return newUNOP(OP_REFGEN, 0,
a0d0e21e
LW		 3551 mod(list(convert(OP_ANONHASH, 0, op)), OP_REFGEN));
3552}
3553
3554OP *
4633a7c4 3555newANONSUB(floor, proto, block)
a0d0e21e 3556I32 floor;
4633a7c4 3557OP *proto;
a0d0e21e
LW		 3558OP *block;
3559{
3560 return newUNOP(OP_REFGEN, 0,
4633a7c4 3561 newSVOP(OP_ANONCODE, 0, (SV*)newSUB(floor, 0, proto, block)));
79072805
LW		 3562}
3563
3564OP *
3565oopsAV(o)
3566OP *o;
3567{
ed6116ce
LW		 3568 switch (o->op_type) {
3569 case OP_PADSV:
3570 o->op_type = OP_PADAV;
3571 o->op_ppaddr = ppaddr[OP_PADAV];
3572 return ref(newUNOP(OP_RV2AV, 0, scalar(o)), OP_RV2AV);
3573
3574 case OP_RV2SV:
79072805
LW		 3575 o->op_type = OP_RV2AV;
3576 o->op_ppaddr = ppaddr[OP_RV2AV];
3577 ref(o, OP_RV2AV);
ed6116ce
LW		 3578 break;
3579
3580 default:
79072805 3581 warn("oops: oopsAV");
ed6116ce
LW		 3582 break;
3583 }
79072805
LW		 3584 return o;
3585}
3586
3587OP *
3588oopsHV(o)
3589OP *o;
3590{
ed6116ce
LW		 3591 switch (o->op_type) {
3592 case OP_PADSV:
3593 case OP_PADAV:
3594 o->op_type = OP_PADHV;
3595 o->op_ppaddr = ppaddr[OP_PADHV];
3596 return ref(newUNOP(OP_RV2HV, 0, scalar(o)), OP_RV2HV);
3597
3598 case OP_RV2SV:
3599 case OP_RV2AV:
79072805
LW		 3600 o->op_type = OP_RV2HV;
3601 o->op_ppaddr = ppaddr[OP_RV2HV];
3602 ref(o, OP_RV2HV);
ed6116ce
LW		 3603 break;
3604
3605 default:
79072805 3606 warn("oops: oopsHV");
ed6116ce
LW		 3607 break;
3608 }
79072805
LW		 3609 return o;
3610}
3611
3612OP *
3613newAVREF(o)
3614OP *o;
3615{
ed6116ce
LW		 3616 if (o->op_type == OP_PADANY) {
3617 o->op_type = OP_PADAV;
3618 o->op_ppaddr = ppaddr[OP_PADAV];
93a17b20 3619 return o;
ed6116ce 3620 }
79072805
LW		 3621 return newUNOP(OP_RV2AV, 0, scalar(o));
3622}
3623
3624OP *
a0d0e21e
LW		 3625newGVREF(type,o)
3626I32 type;
79072805
LW		 3627OP *o;
3628{
a0d0e21e
LW		 3629 if (type == OP_MAPSTART)
3630 return newUNOP(OP_NULL, 0, o);
748a9306 3631 return ref(newUNOP(OP_RV2GV, OPf_REF, o), type);
79072805
LW		 3632}
3633
3634OP *
3635newHVREF(o)
3636OP *o;
3637{
ed6116ce
LW		 3638 if (o->op_type == OP_PADANY) {
3639 o->op_type = OP_PADHV;
3640 o->op_ppaddr = ppaddr[OP_PADHV];
93a17b20 3641 return o;
ed6116ce 3642 }
79072805
LW		 3643 return newUNOP(OP_RV2HV, 0, scalar(o));
3644}
3645
3646OP *
3647oopsCV(o)
3648OP *o;
3649{
463ee0b2 3650 croak("NOT IMPL LINE %d",__LINE__);
79072805
LW		 3651 /* STUB */
3652 return o;
3653}
3654
3655OP *
c07a80fd 3656newCVREF(flags, o)
3657I32 flags;
79072805
LW		 3658OP *o;
3659{
c07a80fd 3660 return newUNOP(OP_RV2CV, flags, scalar(o));
79072805
LW		 3661}
3662
3663OP *
3664newSVREF(o)
3665OP *o;
3666{
ed6116ce
LW		 3667 if (o->op_type == OP_PADANY) {
3668 o->op_type = OP_PADSV;
3669 o->op_ppaddr = ppaddr[OP_PADSV];
93a17b20 3670 return o;
ed6116ce 3671 }
79072805
LW		 3672 return newUNOP(OP_RV2SV, 0, scalar(o));
3673}
3674
3675/* Check routines. */
3676
3677OP *
5f05dabc 3678ck_anoncode(op)
3679OP *op;
3680{
178c6305
CS		 3681 PADOFFSET ix;
3682 SV* name;
3683
3684 name = NEWSV(1106,0);
3685 sv_upgrade(name, SVt_PVNV);
3686 sv_setpvn(name, "&", 1);
3687 SvIVX(name) = -1;
3688 SvNVX(name) = 1;
3689 ix = pad_alloc(op->op_type, SVs_PADMY);
3690 av_store(comppad_name, ix, name);
5f05dabc 3691 av_store(comppad, ix, cSVOP->op_sv);
3692 SvPADMY_on(cSVOP->op_sv);
3693 cSVOP->op_sv = Nullsv;
3694 cSVOP->op_targ = ix;
3695 return op;
3696}
3697
3698OP *
55497cff 3699ck_bitop(op)
3700OP *op;
3701{
3702 op->op_private = hints;
3703 return op;
3704}
3705
3706OP *
79072805
LW		 3707ck_concat(op)
3708OP *op;
3709{
3710 if (cUNOP->op_first->op_type == OP_CONCAT)
3711 op->op_flags |= OPf_STACKED;
3712 return op;
3713}
3714
3715OP *
a0d0e21e 3716ck_spair(op)
79072805
LW		 3717OP *op;
3718{
3719 if (op->op_flags & OPf_KIDS) {
3720 OP* newop;
a0d0e21e 3721 OP* kid;
8ebc5c01 3722 OPCODE type = op->op_type;
3723 op = modkids(ck_fun(op), type);
a0d0e21e
LW		 3724 kid = cUNOP->op_first;
3725 newop = kUNOP->op_first->op_sibling;
3726 if (newop &&
3727 (newop->op_sibling ||
3728 !(opargs[newop->op_type] & OA_RETSCALAR) ||
3729 newop->op_type == OP_PADAV || newop->op_type == OP_PADHV ||
3730 newop->op_type == OP_RV2AV || newop->op_type == OP_RV2HV)) {
3731
79072805 3732 return op;
a0d0e21e
LW		 3733 }
3734 op_free(kUNOP->op_first);
3735 kUNOP->op_first = newop;
3736 }
3737 op->op_ppaddr = ppaddr[++op->op_type];
3738 return ck_fun(op);
3739}
3740
3741OP *
3742ck_delete(op)
3743OP *op;
3744{
3745 op = ck_fun(op);
5f05dabc 3746 op->op_private = 0;
a0d0e21e
LW		 3747 if (op->op_flags & OPf_KIDS) {
3748 OP *kid = cUNOP->op_first;
5f05dabc 3749 if (kid->op_type == OP_HSLICE)
3750 op->op_private |= OPpSLICE;
3751 else if (kid->op_type != OP_HELEM)
3752 croak("%s argument is not a HASH element or slice",
3753 op_desc[op->op_type]);
a0d0e21e 3754 null(kid);
79072805 3755 }
79072805
LW		 3756 return op;
3757}
3758
3759OP *
3760ck_eof(op)
3761OP *op;
3762{
3763 I32 type = op->op_type;
3764
8990e307
LW		 3765 if (op->op_flags & OPf_KIDS) {
3766 if (cLISTOP->op_first->op_type == OP_STUB) {
3767 op_free(op);
3768 op = newUNOP(type, OPf_SPECIAL,
85e6fe83 3769 newGVOP(OP_GV, 0, gv_fetchpv("main'ARGV", TRUE, SVt_PVAV)));
8990e307 3770 }
79072805 3771 return ck_fun(op);
79072805
LW		 3772 }
3773 return op;
3774}
3775
3776OP *
3777ck_eval(op)
3778OP *op;
3779{
85e6fe83 3780 hints |= HINT_BLOCK_SCOPE;
79072805
LW		 3781 if (op->op_flags & OPf_KIDS) {
3782 SVOP *kid = (SVOP*)cUNOP->op_first;
3783
93a17b20
LW		 3784 if (!kid) {
3785 op->op_flags &= ~OPf_KIDS;
8990e307 3786 null(op);
79072805
LW		 3787 }
3788 else if (kid->op_type == OP_LINESEQ) {
3789 LOGOP *enter;
3790
3791 kid->op_next = op->op_next;
3792 cUNOP->op_first = 0;
3793 op_free(op);
3794
3795 Newz(1101, enter, 1, LOGOP);
3796 enter->op_type = OP_ENTERTRY;
3797 enter->op_ppaddr = ppaddr[OP_ENTERTRY];
3798 enter->op_private = 0;
3799
3800 /* establish postfix order */
3801 enter->op_next = (OP*)enter;
3802
463ee0b2 3803 op = prepend_elem(OP_LINESEQ, (OP*)enter, (OP*)kid);
79072805
LW		 3804 op->op_type = OP_LEAVETRY;
3805 op->op_ppaddr = ppaddr[OP_LEAVETRY];
3806 enter->op_other = op;
3807 return op;
3808 }
3809 }
3810 else {
3811 op_free(op);
3812 op = newUNOP(OP_ENTEREVAL, 0, newSVREF(newGVOP(OP_GV, 0, defgv)));
3813 }
a0d0e21e 3814 op->op_targ = (PADOFFSET)hints;
79072805
LW		 3815 return op;
3816}
3817
3818OP *
3819ck_exec(op)
3820OP *op;
3821{
3822 OP *kid;
79072805 3823 if (op->op_flags & OPf_STACKED) {
463ee0b2 3824 op = ck_fun(op);
79072805 3825 kid = cUNOP->op_first->op_sibling;
8990e307
LW		 3826 if (kid->op_type == OP_RV2GV)
3827 null(kid);
79072805 3828 }
463ee0b2
LW		 3829 else
3830 op = listkids(op);
79072805
LW		 3831 return op;
3832}
3833
3834OP *
5f05dabc 3835ck_exists(op)
3836OP *op;
3837{
3838 op = ck_fun(op);
3839 if (op->op_flags & OPf_KIDS) {
3840 OP *kid = cUNOP->op_first;
3841 if (kid->op_type != OP_HELEM)
3842 croak("%s argument is not a HASH element", op_desc[op->op_type]);
3843 null(kid);
3844 }
3845 return op;
3846}
3847
3848OP *
79072805
LW		 3849ck_gvconst(o)
3850register OP *o;
3851{
3852 o = fold_constants(o);
3853 if (o->op_type == OP_CONST)
3854 o->op_type = OP_GV;
3855 return o;
3856}
3857
3858OP *
3859ck_rvconst(op)
3860register OP *op;
3861{
3862 SVOP *kid = (SVOP*)cUNOP->op_first;
85e6fe83 3863
c07a80fd 3864 op->op_private |= (hints & HINT_STRICT_REFS);
79072805 3865 if (kid->op_type == OP_CONST) {
44a8e56a 3866 char *name;
3867 int iscv;
3868 GV *gv;
3869
3870 name = SvPV(kid->op_sv, na);
3871 if ((hints & HINT_STRICT_REFS) && (kid->op_private & OPpCONST_BARE)) {
3872 char *badthing = Nullch;
3873 switch (op->op_type) {
3874 case OP_RV2SV:
3875 badthing = "a SCALAR";
3876 break;
3877 case OP_RV2AV:
3878 badthing = "an ARRAY";
3879 break;
3880 case OP_RV2HV:
3881 badthing = "a HASH";
3882 break;
3883 }
3884 if (badthing)
3885 croak(
3886 "Can't use bareword (\"%s\") as %s ref while \"strict refs\" in use",
3887 name, badthing);
3888 }
79072805 3889 kid->op_type = OP_GV;
44a8e56a 3890 iscv = (op->op_type == OP_RV2CV) * 2;
a0d0e21e 3891 for (gv = 0; !gv; iscv++) {
748a9306
LW		 3892 /*
3893 * This is a little tricky. We only want to add the symbol if we
3894 * didn't add it in the lexer. Otherwise we get duplicate strict
3895 * warnings. But if we didn't add it in the lexer, we must at
3896 * least pretend like we wanted to add it even if it existed before,
3897 * or we get possible typo warnings. OPpCONST_ENTERED says
3898 * whether the lexer already added THIS instance of this symbol.
3899 */
44a8e56a 3900 gv = gv_fetchpv(name,
748a9306 3901 iscv | !(kid->op_private & OPpCONST_ENTERED),
a0d0e21e
LW		 3902 iscv
3903 ? SVt_PVCV
3904 : op->op_type == OP_RV2SV
3905 ? SVt_PV
3906 : op->op_type == OP_RV2AV
3907 ? SVt_PVAV
3908 : op->op_type == OP_RV2HV
3909 ? SVt_PVHV
3910 : SVt_PVGV);
3911 }
adbc6bb1 3912 SvREFCNT_dec(kid->op_sv);
a0d0e21e 3913 kid->op_sv = SvREFCNT_inc(gv);
79072805
LW		 3914 }
3915 return op;
3916}
3917
3918OP *
79072805
LW		 3919ck_ftst(op)
3920OP *op;
3921{
3922 I32 type = op->op_type;
3923
a0d0e21e 3924 if (op->op_flags & OPf_REF)
79072805
LW		 3925 return op;
3926
3927 if (op->op_flags & OPf_KIDS) {
3928 SVOP *kid = (SVOP*)cUNOP->op_first;
3929
3930 if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
a0d0e21e 3931 OP *newop = newGVOP(type, OPf_REF,
85e6fe83 3932 gv_fetchpv(SvPVx(kid->op_sv, na), TRUE, SVt_PVIO));
79072805
LW		 3933 op_free(op);
3934 return newop;
3935 }
3936 }
3937 else {
3938 op_free(op);
3939 if (type == OP_FTTTY)
a0d0e21e 3940 return newGVOP(type, OPf_REF, gv_fetchpv("main'STDIN", TRUE,
85e6fe83 3941 SVt_PVIO));
79072805
LW		 3942 else
3943 return newUNOP(type, 0, newSVREF(newGVOP(OP_GV, 0, defgv)));
3944 }
3945 return op;
3946}
3947
3948OP *
3949ck_fun(op)
3950OP *op;
3951{
3952 register OP *kid;
3953 OP **tokid;
3954 OP *sibl;
3955 I32 numargs = 0;
a0d0e21e
LW		 3956 int type = op->op_type;
3957 register I32 oa = opargs[type] >> OASHIFT;
79072805
LW		 3958
3959 if (op->op_flags & OPf_STACKED) {
3960 if ((oa & OA_OPTIONAL) && (oa >> 4) && !((oa >> 4) & OA_OPTIONAL))
3961 oa &= ~OA_OPTIONAL;
3962 else
3963 return no_fh_allowed(op);
3964 }
3965
3966 if (op->op_flags & OPf_KIDS) {
3967 tokid = &cLISTOP->op_first;
3968 kid = cLISTOP->op_first;
8990e307
LW		 3969 if (kid->op_type == OP_PUSHMARK ||
3970 kid->op_type == OP_NULL && kid->op_targ == OP_PUSHMARK)
3971 {
79072805
LW		 3972 tokid = &kid->op_sibling;
3973 kid = kid->op_sibling;
3974 }
a0d0e21e
LW		 3975 if (!kid && opargs[type] & OA_DEFGV)
3976 *tokid = kid = newSVREF(newGVOP(OP_GV, 0, defgv));
79072805
LW		 3977
3978 while (oa && kid) {
3979 numargs++;
3980 sibl = kid->op_sibling;
3981 switch (oa & 7) {
3982 case OA_SCALAR:
3983 scalar(kid);
3984 break;
3985 case OA_LIST:
3986 if (oa < 16) {
3987 kid = 0;
3988 continue;
3989 }
3990 else
3991 list(kid);
3992 break;
3993 case OA_AVREF:
3994 if (kid->op_type == OP_CONST &&
3995 (kid->op_private & OPpCONST_BARE)) {
463ee0b2 3996 char *name = SvPVx(((SVOP*)kid)->op_sv, na);
79072805 3997 OP *newop = newAVREF(newGVOP(OP_GV, 0,
85e6fe83 3998 gv_fetchpv(name, TRUE, SVt_PVAV) ));
463ee0b2 3999 if (dowarn)
ff0cee69 4000 warn("Array @%s missing the @ in argument %ld of %s()",
4001 name, (long)numargs, op_desc[type]);
79072805
LW		 4002 op_free(kid);
4003 kid = newop;
4004 kid->op_sibling = sibl;
4005 *tokid = kid;
4006 }
8990e307 4007 else if (kid->op_type != OP_RV2AV && kid->op_type != OP_PADAV)
c07a80fd 4008 bad_type(numargs, "array", op_desc[op->op_type], kid);
a0d0e21e 4009 mod(kid, type);
79072805
LW		 4010 break;
4011 case OA_HVREF:
4012 if (kid->op_type == OP_CONST &&
4013 (kid->op_private & OPpCONST_BARE)) {
463ee0b2 4014 char *name = SvPVx(((SVOP*)kid)->op_sv, na);
79072805 4015 OP *newop = newHVREF(newGVOP(OP_GV, 0,
85e6fe83 4016 gv_fetchpv(name, TRUE, SVt_PVHV) ));
463ee0b2 4017 if (dowarn)
ff0cee69 4018 warn("Hash %%%s missing the %% in argument %ld of %s()",
4019 name, (long)numargs, op_desc[type]);
79072805
LW		 4020 op_free(kid);
4021 kid = newop;
4022 kid->op_sibling = sibl;
4023 *tokid = kid;
4024 }
8990e307 4025 else if (kid->op_type != OP_RV2HV && kid->op_type != OP_PADHV)
c07a80fd 4026 bad_type(numargs, "hash", op_desc[op->op_type], kid);
a0d0e21e 4027 mod(kid, type);
79072805
LW		 4028 break;
4029 case OA_CVREF:
4030 {
a0d0e21e 4031 OP *newop = newUNOP(OP_NULL, 0, kid);
79072805
LW		 4032 kid->op_sibling = 0;
4033 linklist(kid);
4034 newop->op_next = newop;
4035 kid = newop;
4036 kid->op_sibling = sibl;
4037 *tokid = kid;
4038 }
4039 break;
4040 case OA_FILEREF:
4041 if (kid->op_type != OP_GV) {
4042 if (kid->op_type == OP_CONST &&
4043 (kid->op_private & OPpCONST_BARE)) {
4044 OP *newop = newGVOP(OP_GV, 0,
85e6fe83
LW		 4045 gv_fetchpv(SvPVx(((SVOP*)kid)->op_sv, na), TRUE,
4046 SVt_PVIO) );
79072805
LW		 4047 op_free(kid);
4048 kid = newop;
4049 }
4050 else {
4051 kid->op_sibling = 0;
4052 kid = newUNOP(OP_RV2GV, 0, scalar(kid));
4053 }
4054 kid->op_sibling = sibl;
4055 *tokid = kid;
4056 }
4057 scalar(kid);
4058 break;
4059 case OA_SCALARREF:
a0d0e21e 4060 mod(scalar(kid), type);
79072805
LW		 4061 break;
4062 }
4063 oa >>= 4;
4064 tokid = &kid->op_sibling;
4065 kid = kid->op_sibling;
4066 }
c07a80fd 4067 op->op_private |= numargs;
79072805 4068 if (kid)
c07a80fd 4069 return too_many_arguments(op,op_desc[op->op_type]);
79072805
LW		 4070 listkids(op);
4071 }
a0d0e21e
LW		 4072 else if (opargs[type] & OA_DEFGV) {
4073 op_free(op);
4074 return newUNOP(type, 0, newSVREF(newGVOP(OP_GV, 0, defgv)));
4075 }
4076
79072805
LW		 4077 if (oa) {
4078 while (oa & OA_OPTIONAL)
4079 oa >>= 4;
4080 if (oa && oa != OA_LIST)
c07a80fd 4081 return too_few_arguments(op,op_desc[op->op_type]);
79072805
LW		 4082 }
4083 return op;
4084}
4085
4086OP *
4087ck_glob(op)
4088OP *op;
4089{
b1cb66bf 4090 GV *gv = gv_fetchpv("glob", FALSE, SVt_PVCV);
4091
4092 if (gv && GvIMPORTED_CV(gv)) {
46fc3d4c 4093 static int glob_index;
4094
4095 append_elem(OP_GLOB, op,
4096 newSVOP(OP_CONST, 0, newSViv(glob_index++)));
b1cb66bf 4097 op->op_type = OP_LIST;
4098 op->op_ppaddr = ppaddr[OP_LIST];
46fc3d4c 4099 ((LISTOP*)op)->op_first->op_type = OP_PUSHMARK;
4100 ((LISTOP*)op)->op_first->op_ppaddr = ppaddr[OP_PUSHMARK];
b1cb66bf 4101 op = newUNOP(OP_ENTERSUB, OPf_STACKED,
4102 append_elem(OP_LIST, op,
4103 scalar(newUNOP(OP_RV2CV, 0,
4104 newGVOP(OP_GV, 0, gv)))));
4105 return ck_subr(op);
4106 }
0a753a76 4107 if ((op->op_flags & OPf_KIDS) && !cLISTOP->op_first->op_sibling)
4108 append_elem(OP_GLOB, op, newSVREF(newGVOP(OP_GV, 0, defgv)));
b1cb66bf 4109 gv = newGVgen("main");
a0d0e21e 4110 gv_IOadd(gv);
79072805
LW		 4111 append_elem(OP_GLOB, op, newGVOP(OP_GV, 0, gv));
4112 scalarkids(op);
a0d0e21e 4113 return ck_fun(op);
79072805
LW		 4114}
4115
4116OP *
4117ck_grep(op)
4118OP *op;
4119{
4120 LOGOP *gwop;
4121 OP *kid;
a0d0e21e 4122 OPCODE type = op->op_type == OP_GREPSTART ? OP_GREPWHILE : OP_MAPWHILE;
79072805 4123
a0d0e21e
LW		 4124 op->op_ppaddr = ppaddr[OP_GREPSTART];
4125 Newz(1101, gwop, 1, LOGOP);
4126
93a17b20 4127 if (op->op_flags & OPf_STACKED) {
a0d0e21e 4128 OP* k;
93a17b20 4129 op = ck_sort(op);
8e07c86e 4130 kid = cLISTOP->op_first->op_sibling;
a0d0e21e
LW		 4131 for (k = cLISTOP->op_first->op_sibling->op_next; k; k = k->op_next) {
4132 kid = k;
4133 }
4134 kid->op_next = (OP*)gwop;
93a17b20
LW		 4135 op->op_flags &= ~OPf_STACKED;
4136 }
a0d0e21e
LW		 4137 kid = cLISTOP->op_first->op_sibling;
4138 if (type == OP_MAPWHILE)
4139 list(kid);
4140 else
4141 scalar(kid);
79072805
LW		 4142 op = ck_fun(op);
4143 if (error_count)
4144 return op;
a0d0e21e 4145 kid = cLISTOP->op_first->op_sibling;
79072805 4146 if (kid->op_type != OP_NULL)
463ee0b2 4147 croak("panic: ck_grep");
79072805
LW		 4148 kid = kUNOP->op_first;
4149
a0d0e21e
LW		 4150 gwop->op_type = type;
4151 gwop->op_ppaddr = ppaddr[type];
4152 gwop->op_first = listkids(op);
79072805
LW		 4153 gwop->op_flags |= OPf_KIDS;
4154 gwop->op_private = 1;
4155 gwop->op_other = LINKLIST(kid);
a0d0e21e 4156 gwop->op_targ = pad_alloc(type, SVs_PADTMP);
79072805
LW		 4157 kid->op_next = (OP*)gwop;
4158
a0d0e21e
LW		 4159 kid = cLISTOP->op_first->op_sibling;
4160 if (!kid || !kid->op_sibling)
c07a80fd 4161 return too_few_arguments(op,op_desc[op->op_type]);
a0d0e21e
LW		 4162 for (kid = kid->op_sibling; kid; kid = kid->op_sibling)
4163 mod(kid, OP_GREPSTART);
4164
79072805
LW		 4165 return (OP*)gwop;
4166}
4167
4168OP *
4169ck_index(op)
4170OP *op;
4171{
4172 if (op->op_flags & OPf_KIDS) {
4173 OP *kid = cLISTOP->op_first->op_sibling; /* get past pushmark */
4174 if (kid && kid->op_type == OP_CONST)
bbce6d69 4175 fbm_compile(((SVOP*)kid)->op_sv);
79072805
LW		 4176 }
4177 return ck_fun(op);
4178}
4179
4180OP *
4181ck_lengthconst(op)
4182OP *op;
4183{
4184 /* XXX length optimization goes here */
a0d0e21e 4185 return ck_fun(op);
79072805
LW		 4186}
4187
4188OP *
4189ck_lfun(op)
4190OP *op;
4191{
8ebc5c01 4192 OPCODE type = op->op_type;
4193 return modkids(ck_fun(op), type);
79072805
LW		 4194}
4195
4196OP *
8990e307
LW		 4197ck_rfun(op)
4198OP *op;
4199{
8ebc5c01 4200 OPCODE type = op->op_type;
4201 return refkids(ck_fun(op), type);
8990e307
LW		 4202}
4203
4204OP *
79072805
LW		 4205ck_listiob(op)
4206OP *op;
4207{
4208 register OP *kid;
4209
4210 kid = cLISTOP->op_first;
4211 if (!kid) {
8990e307 4212 op = force_list(op);
79072805
LW		 4213 kid = cLISTOP->op_first;
4214 }
4215 if (kid->op_type == OP_PUSHMARK)
4216 kid = kid->op_sibling;
4217 if (kid && op->op_flags & OPf_STACKED)
4218 kid = kid->op_sibling;
4219 else if (kid && !kid->op_sibling) { /* print HANDLE; */
4220 if (kid->op_type == OP_CONST && kid->op_private & OPpCONST_BARE) {
4221 op->op_flags |= OPf_STACKED; /* make it a filehandle */
748a9306 4222 kid = newUNOP(OP_RV2GV, OPf_REF, scalar(kid));
79072805
LW		 4223 cLISTOP->op_first->op_sibling = kid;
4224 cLISTOP->op_last = kid;
4225 kid = kid->op_sibling;
4226 }
4227 }
4228
4229 if (!kid)
4230 append_elem(op->op_type, op, newSVREF(newGVOP(OP_GV, 0, defgv)) );
4231
bbce6d69 4232 op = listkids(op);
4233
4234 op->op_private = 0;
36477c24 4235#ifdef USE_LOCALE
bbce6d69 4236 if (hints & HINT_LOCALE)
4237 op->op_private |= OPpLOCALE;
4238#endif
4239
4240 return op;
4241}
4242
4243OP *
4244ck_fun_locale(op)
4245OP *op;
4246{
4247 op = ck_fun(op);
4248
4249 op->op_private = 0;
36477c24 4250#ifdef USE_LOCALE
bbce6d69 4251 if (hints & HINT_LOCALE)
4252 op->op_private |= OPpLOCALE;
4253#endif
4254
4255 return op;
4256}
4257
4258OP *
4259ck_scmp(op)
4260OP *op;
4261{
4262 op->op_private = 0;
36477c24 4263#ifdef USE_LOCALE
bbce6d69 4264 if (hints & HINT_LOCALE)
4265 op->op_private |= OPpLOCALE;
4266#endif
36477c24 4267
bbce6d69 4268 return op;
79072805
LW		 4269}
4270
4271OP *
4272ck_match(op)
4273OP *op;
4274{
4275 cPMOP->op_pmflags |= PMf_RUNTIME;
4633a7c4 4276 cPMOP->op_pmpermflags |= PMf_RUNTIME;
79072805
LW		 4277 return op;
4278}
4279
4280OP *
4281ck_null(op)
4282OP *op;
4283{
4284 return op;
4285}
4286
4287OP *
4288ck_repeat(op)
4289OP *op;
4290{
4291 if (cBINOP->op_first->op_flags & OPf_PARENS) {
c07a80fd 4292 op->op_private |= OPpREPEAT_DOLIST;
8990e307 4293 cBINOP->op_first = force_list(cBINOP->op_first);
79072805
LW		 4294 }
4295 else
4296 scalar(op);
4297 return op;
4298}
4299
4300OP *
8990e307
LW		 4301ck_require(op)
4302OP *op;
4303{
a0d0e21e 4304 if (op->op_flags & OPf_KIDS) { /* Shall we supply missing .pm? */
8990e307
LW		 4305 SVOP *kid = (SVOP*)cUNOP->op_first;
4306
4307 if (kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE)) {
8990e307 4308 char *s;
a0d0e21e
LW		 4309 for (s = SvPVX(kid->op_sv); *s; s++) {
4310 if (*s == ':' && s[1] == ':') {
4311 *s = '/';
1aef975c 4312 Move(s+2, s+1, strlen(s+2)+1, char);
a0d0e21e
LW		 4313 --SvCUR(kid->op_sv);
4314 }
8990e307 4315 }
a0d0e21e 4316 sv_catpvn(kid->op_sv, ".pm", 3);
8990e307
LW		 4317 }
4318 }
4319 return ck_fun(op);
4320}
4321
4322OP *
79072805
LW		 4323ck_retarget(op)
4324OP *op;
4325{
463ee0b2 4326 croak("NOT IMPL LINE %d",__LINE__);
79072805
LW		 4327 /* STUB */
4328 return op;
4329}
4330
4331OP *
4332ck_select(op)
4333OP *op;
4334{
c07a80fd 4335 OP* kid;
79072805 4336 if (op->op_flags & OPf_KIDS) {
c07a80fd 4337 kid = cLISTOP->op_first->op_sibling; /* get past pushmark */
2304df62 4338 if (kid && kid->op_sibling) {
79072805
LW		 4339 op->op_type = OP_SSELECT;
4340 op->op_ppaddr = ppaddr[OP_SSELECT];
4341 op = ck_fun(op);
4342 return fold_constants(op);
4343 }
4344 }
c07a80fd 4345 op = ck_fun(op);
4346 kid = cLISTOP->op_first->op_sibling; /* get past pushmark */
4347 if (kid && kid->op_type == OP_RV2GV)
4348 kid->op_private &= ~HINT_STRICT_REFS;
4349 return op;
79072805
LW		 4350}
4351
4352OP *
4353ck_shift(op)
4354OP *op;
4355{
4356 I32 type = op->op_type;
4357
4358 if (!(op->op_flags & OPf_KIDS)) {
4359 op_free(op);
4360 return newUNOP(type, 0,
4361 scalar(newUNOP(OP_RV2AV, 0,
b1cb66bf 4362 scalar(newGVOP(OP_GV, 0, subline
4363 ? defgv
4364 : gv_fetchpv("ARGV", TRUE, SVt_PVAV) )))));
79072805 4365 }
463ee0b2 4366 return scalar(modkids(ck_fun(op), type));
79072805
LW		 4367}
4368
4369OP *
4370ck_sort(op)
4371OP *op;
4372{
bbce6d69 4373 op->op_private = 0;
36477c24 4374#ifdef USE_LOCALE
bbce6d69 4375 if (hints & HINT_LOCALE)
4376 op->op_private |= OPpLOCALE;
4377#endif
4378
79072805
LW		 4379 if (op->op_flags & OPf_STACKED) {
4380 OP *kid = cLISTOP->op_first->op_sibling; /* get past pushmark */
463ee0b2
LW		 4381 OP *k;
4382 kid = kUNOP->op_first; /* get past rv2gv */
79072805 4383
463ee0b2 4384 if (kid->op_type == OP_SCOPE || kid->op_type == OP_LEAVE) {
79072805 4385 linklist(kid);
463ee0b2
LW		 4386 if (kid->op_type == OP_SCOPE) {
4387 k = kid->op_next;
4388 kid->op_next = 0;
79072805 4389 }
463ee0b2 4390 else if (kid->op_type == OP_LEAVE) {
748a9306
LW		 4391 if (op->op_type == OP_SORT) {
4392 null(kid); /* wipe out leave */
4393 kid->op_next = kid;
463ee0b2 4394
748a9306
LW		 4395 for (k = kLISTOP->op_first->op_next; k; k = k->op_next) {
4396 if (k->op_next == kid)
4397 k->op_next = 0;
4398 }
463ee0b2 4399 }
748a9306
LW		 4400 else
4401 kid->op_next = 0; /* just disconnect the leave */
a0d0e21e 4402 k = kLISTOP->op_first;
463ee0b2 4403 }
a0d0e21e
LW		 4404 peep(k);
4405
463ee0b2 4406 kid = cLISTOP->op_first->op_sibling; /* get past pushmark */
8990e307 4407 null(kid); /* wipe out rv2gv */
a0d0e21e
LW		 4408 if (op->op_type == OP_SORT)
4409 kid->op_next = kid;
4410 else
4411 kid->op_next = k;
79072805
LW		 4412 op->op_flags |= OPf_SPECIAL;
4413 }
4414 }
bbce6d69 4415
79072805
LW		 4416 return op;
4417}
4418
4419OP *
4420ck_split(op)
4421OP *op;
4422{
4423 register OP *kid;
ed6116ce 4424 PMOP* pm;
79072805
LW		 4425
4426 if (op->op_flags & OPf_STACKED)
4427 return no_fh_allowed(op);
4428
79072805 4429 kid = cLISTOP->op_first;
8990e307 4430 if (kid->op_type != OP_NULL)
463ee0b2 4431 croak("panic: ck_split");
8990e307
LW		 4432 kid = kid->op_sibling;
4433 op_free(cLISTOP->op_first);
4434 cLISTOP->op_first = kid;
85e6fe83 4435 if (!kid) {
8990e307 4436 cLISTOP->op_first = kid = newSVOP(OP_CONST, 0, newSVpv(" ", 1));
85e6fe83
LW		 4437 cLISTOP->op_last = kid; /* There was only one element previously */
4438 }
79072805
LW		 4439
4440 if (kid->op_type != OP_MATCH) {
4441 OP *sibl = kid->op_sibling;
463ee0b2 4442 kid->op_sibling = 0;
79072805
LW		 4443 kid = pmruntime( newPMOP(OP_MATCH, OPf_SPECIAL), kid, Nullop);
4444 if (cLISTOP->op_first == cLISTOP->op_last)
4445 cLISTOP->op_last = kid;
4446 cLISTOP->op_first = kid;
4447 kid->op_sibling = sibl;
4448 }
ed6116ce
LW		 4449 pm = (PMOP*)kid;
4450 if (pm->op_pmshort && !(pm->op_pmflags & PMf_ALL)) {
8990e307 4451 SvREFCNT_dec(pm->op_pmshort); /* can't use substring to optimize */
ed6116ce
LW		 4452 pm->op_pmshort = 0;
4453 }
79072805
LW		 4454
4455 kid->op_type = OP_PUSHRE;
4456 kid->op_ppaddr = ppaddr[OP_PUSHRE];
4457 scalar(kid);
4458
4459 if (!kid->op_sibling)
4460 append_elem(OP_SPLIT, op, newSVREF(newGVOP(OP_GV, 0, defgv)) );
4461
4462 kid = kid->op_sibling;
4463 scalar(kid);
4464
4465 if (!kid->op_sibling)
4466 append_elem(OP_SPLIT, op, newSVOP(OP_CONST, 0, newSViv(0)));
4467
4468 kid = kid->op_sibling;
4469 scalar(kid);
4470
4471 if (kid->op_sibling)
c07a80fd 4472 return too_many_arguments(op,op_desc[op->op_type]);
79072805
LW		 4473
4474 return op;
4475}
4476
4477OP *
4478ck_subr(op)
4479OP *op;
4480{
4633a7c4
LW		 4481 OP *prev = ((cUNOP->op_first->op_sibling)
4482 ? cUNOP : ((UNOP*)cUNOP->op_first))->op_first;
4483 OP *o = prev->op_sibling;
4484 OP *cvop;
4485 char *proto = 0;
4486 CV *cv = 0;
46fc3d4c 4487 GV *namegv = 0;
4633a7c4
LW		 4488 int optional = 0;
4489 I32 arg = 0;
4490
4491 for (cvop = o; cvop->op_sibling; cvop = cvop->op_sibling) ;
4492 if (cvop->op_type == OP_RV2CV) {
4493 SVOP* tmpop;
c07a80fd 4494 op->op_private |= (cvop->op_private & OPpENTERSUB_AMPER);
4633a7c4
LW		 4495 null(cvop); /* disable rv2cv */
4496 tmpop = (SVOP*)((UNOP*)cvop)->op_first;
4497 if (tmpop->op_type == OP_GV) {
8ebc5c01 4498 cv = GvCVu(tmpop->op_sv);
46fc3d4c 4499 if (cv && SvPOK(cv) && !(op->op_private & OPpENTERSUB_AMPER)) {
4500 namegv = CvANON(cv) ? (GV*)tmpop->op_sv : CvGV(cv);
4501 proto = SvPV((SV*)cv, na);
4502 }
4633a7c4
LW		 4503 }
4504 }
c07a80fd 4505 op->op_private |= (hints & HINT_STRICT_REFS);
8990e307 4506 if (perldb && curstash != debstash)
c07a80fd 4507 op->op_private |= OPpENTERSUB_DB;
4633a7c4
LW		 4508 while (o != cvop) {
4509 if (proto) {
4510 switch (*proto) {
4511 case '\0':
46fc3d4c 4512 return too_many_arguments(op, gv_ename(namegv));
4633a7c4
LW		 4513 case ';':
4514 optional = 1;
4515 proto++;
4516 continue;
4517 case '$':
4518 proto++;
4519 arg++;
4520 scalar(o);
4521 break;
4522 case '%':
4523 case '@':
4524 list(o);
4525 arg++;
4526 break;
4527 case '&':
4528 proto++;
4529 arg++;
4530 if (o->op_type != OP_REFGEN && o->op_type != OP_UNDEF)
46fc3d4c 4531 bad_type(arg, "block", gv_ename(namegv), o);
4633a7c4
LW		 4532 break;
4533 case '*':
4534 proto++;
4535 arg++;
4536 if (o->op_type == OP_RV2GV)
4537 goto wrapref;
4538 {
4539 OP* kid = o;
4540 o = newUNOP(OP_RV2GV, 0, kid);
4541 o->op_sibling = kid->op_sibling;
4542 kid->op_sibling = 0;
4543 prev->op_sibling = o;
4544 }
4545 goto wrapref;
4546 case '\\':
4547 proto++;
4548 arg++;
4549 switch (*proto++) {
4550 case '*':
4551 if (o->op_type != OP_RV2GV)
46fc3d4c 4552 bad_type(arg, "symbol", gv_ename(namegv), o);
4633a7c4
LW		 4553 goto wrapref;
4554 case '&':
4555 if (o->op_type != OP_RV2CV)
46fc3d4c 4556 bad_type(arg, "sub", gv_ename(namegv), o);
4633a7c4
LW		 4557 goto wrapref;
4558 case '$':
4559 if (o->op_type != OP_RV2SV && o->op_type != OP_PADSV)
46fc3d4c 4560 bad_type(arg, "scalar", gv_ename(namegv), o);
4633a7c4
LW		 4561 goto wrapref;
4562 case '@':
4563 if (o->op_type != OP_RV2AV && o->op_type != OP_PADAV)
46fc3d4c 4564 bad_type(arg, "array", gv_ename(namegv), o);
4633a7c4
LW		 4565 goto wrapref;
4566 case '%':
4567 if (o->op_type != OP_RV2HV && o->op_type != OP_PADHV)
46fc3d4c 4568 bad_type(arg, "hash", gv_ename(namegv), o);
4633a7c4
LW		 4569 wrapref:
4570 {
4571 OP* kid = o;
4572 o = newUNOP(OP_REFGEN, 0, kid);
4573 o->op_sibling = kid->op_sibling;
4574 kid->op_sibling = 0;
4575 prev->op_sibling = o;
4576 }
4577 break;
4578 default: goto oops;
4579 }
4580 break;
b1cb66bf 4581 case ' ':
4582 proto++;
4583 continue;
4633a7c4
LW		 4584 default:
4585 oops:
4586 croak("Malformed prototype for %s: %s",
46fc3d4c 4587 gv_ename(namegv), SvPV((SV*)cv, na));
4633a7c4
LW		 4588 }
4589 }
4590 else
4591 list(o);
68dc0745 4592 mod(o, OP_ENTERSUB);
4633a7c4
LW		 4593 prev = o;
4594 o = o->op_sibling;
4595 }
4596 if (proto && !optional && *proto == '$')
46fc3d4c 4597 return too_few_arguments(op, gv_ename(namegv));
79072805
LW		 4598 return op;
4599}
4600
4601OP *
8990e307
LW		 4602ck_svconst(op)
4603OP *op;
4604{
4605 SvREADONLY_on(cSVOP->op_sv);
4606 return op;
4607}
4608
4609OP *
79072805
LW		 4610ck_trunc(op)
4611OP *op;
4612{
4613 if (op->op_flags & OPf_KIDS) {
4614 SVOP *kid = (SVOP*)cUNOP->op_first;
4615
a0d0e21e
LW		 4616 if (kid->op_type == OP_NULL)
4617 kid = (SVOP*)kid->op_sibling;
4618 if (kid &&
4619 kid->op_type == OP_CONST && (kid->op_private & OPpCONST_BARE))
79072805
LW		 4620 op->op_flags |= OPf_SPECIAL;
4621 }
4622 return ck_fun(op);
4623}
4624
463ee0b2
LW		 4625/* A peephole optimizer. We visit the ops in the order they're to execute. */
4626
79072805 4627void
a0d0e21e
LW		 4628peep(o)
4629register OP* o;
79072805
LW		 4630{
4631 register OP* oldop = 0;
a0d0e21e 4632 if (!o || o->op_seq)
79072805 4633 return;
a0d0e21e
LW		 4634 ENTER;
4635 SAVESPTR(op);
4636 SAVESPTR(curcop);
4637 for (; o; o = o->op_next) {
4638 if (o->op_seq)
4639 break;
c07a80fd 4640 if (!op_seqmax)
4641 op_seqmax++;
a0d0e21e
LW		 4642 op = o;
4643 switch (o->op_type) {
4644 case OP_NEXTSTATE:
4645 case OP_DBSTATE:
4646 curcop = ((COP*)o); /* for warnings */
c07a80fd 4647 o->op_seq = op_seqmax++;
a0d0e21e
LW		 4648 break;
4649
4650 case OP_CONCAT:
4651 case OP_CONST:
4652 case OP_JOIN:
4653 case OP_UC:
4654 case OP_UCFIRST:
4655 case OP_LC:
4656 case OP_LCFIRST:
4657 case OP_QUOTEMETA:
4658 if (o->op_next->op_type == OP_STRINGIFY)
4659 null(o->op_next);
c07a80fd 4660 o->op_seq = op_seqmax++;
a0d0e21e 4661 break;
8990e307 4662 case OP_STUB:
54310121 4663 if ((o->op_flags & OPf_WANT) != OPf_WANT_LIST) {
c07a80fd 4664 o->op_seq = op_seqmax++;
54310121 4665 break; /* Scalar stub must produce undef. List stub is noop */
8990e307 4666 }
748a9306 4667 goto nothin;
79072805 4668 case OP_NULL:
748a9306
LW		 4669 if (o->op_targ == OP_NEXTSTATE || o->op_targ == OP_DBSTATE)
4670 curcop = ((COP*)op);
4671 goto nothin;
79072805 4672 case OP_SCALAR:
93a17b20 4673 case OP_LINESEQ:
463ee0b2 4674 case OP_SCOPE:
748a9306 4675 nothin:
a0d0e21e
LW		 4676 if (oldop && o->op_next) {
4677 oldop->op_next = o->op_next;
79072805
LW		 4678 continue;
4679 }
c07a80fd 4680 o->op_seq = op_seqmax++;
79072805
LW		 4681 break;
4682
4683 case OP_GV:
a0d0e21e 4684 if (o->op_next->op_type == OP_RV2SV) {
5f05dabc 4685 if (!(o->op_next->op_private & OPpDEREF)) {
a0d0e21e
LW		 4686 null(o->op_next);
4687 o->op_private |= o->op_next->op_private & OPpLVAL_INTRO;
4688 o->op_next = o->op_next->op_next;
4689 o->op_type = OP_GVSV;
4690 o->op_ppaddr = ppaddr[OP_GVSV];
8990e307
LW		 4691 }
4692 }
a0d0e21e
LW		 4693 else if (o->op_next->op_type == OP_RV2AV) {
4694 OP* pop = o->op_next->op_next;
4695 IV i;
8990e307 4696 if (pop->op_type == OP_CONST &&
a0d0e21e 4697 (op = pop->op_next) &&
8990e307 4698 pop->op_next->op_type == OP_AELEM &&
68dc0745 4699 !(pop->op_next->op_private &
4700 (OPpLVAL_INTRO|OPpLVAL_DEFER|OPpDEREF)) &&
a0d0e21e
LW		 4701 (i = SvIV(((SVOP*)pop)->op_sv) - compiling.cop_arybase)
4702 <= 255 &&
8990e307
LW		 4703 i >= 0)
4704 {
748a9306 4705 SvREFCNT_dec(((SVOP*)pop)->op_sv);
a0d0e21e 4706 null(o->op_next);
8990e307
LW		 4707 null(pop->op_next);
4708 null(pop);
a0d0e21e
LW		 4709 o->op_flags |= pop->op_next->op_flags & OPf_MOD;
4710 o->op_next = pop->op_next->op_next;
4711 o->op_type = OP_AELEMFAST;
4712 o->op_ppaddr = ppaddr[OP_AELEMFAST];
4713 o->op_private = (U8)i;
a6006777 4714 GvAVn(((GVOP*)o)->op_gv);
8990e307 4715 }
79072805 4716 }
c07a80fd 4717 o->op_seq = op_seqmax++;
79072805
LW		 4718 break;
4719
a0d0e21e 4720 case OP_MAPWHILE:
79072805
LW		 4721 case OP_GREPWHILE:
4722 case OP_AND:
4723 case OP_OR:
c07a80fd 4724 o->op_seq = op_seqmax++;
79072805
LW		 4725 peep(cLOGOP->op_other);
4726 break;
4727
4728 case OP_COND_EXPR:
c07a80fd 4729 o->op_seq = op_seqmax++;
79072805
LW		 4730 peep(cCONDOP->op_true);
4731 peep(cCONDOP->op_false);
4732 break;
4733
4734 case OP_ENTERLOOP:
c07a80fd 4735 o->op_seq = op_seqmax++;
79072805
LW		 4736 peep(cLOOP->op_redoop);
4737 peep(cLOOP->op_nextop);
4738 peep(cLOOP->op_lastop);
4739 break;
4740
4741 case OP_MATCH:
4742 case OP_SUBST:
c07a80fd 4743 o->op_seq = op_seqmax++;
a0d0e21e 4744 peep(cPMOP->op_pmreplstart);
79072805
LW		 4745 break;
4746
a0d0e21e 4747 case OP_EXEC:
c07a80fd 4748 o->op_seq = op_seqmax++;
a0d0e21e
LW		 4749 if (dowarn && o->op_next && o->op_next->op_type == OP_NEXTSTATE) {
4750 if (o->op_next->op_sibling &&
4751 o->op_next->op_sibling->op_type != OP_DIE) {
4752 line_t oldline = curcop->cop_line;
4753
4754 curcop->cop_line = ((COP*)o->op_next)->cop_line;
4755 warn("Statement unlikely to be reached");
4756 warn("(Maybe you meant system() when you said exec()?)\n");
4757 curcop->cop_line = oldline;
4758 }
4759 }
4760 break;
79072805 4761 default:
c07a80fd 4762 o->op_seq = op_seqmax++;
79072805
LW		 4763 break;
4764 }
a0d0e21e 4765 oldop = o;
79072805 4766 }
a0d0e21e 4767 LEAVE;
79072805 4768}
Unnamed repository; edit this file 'description' to name the repository.