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
[perl #63540] bizarre closure lossage
[perl5.git] / op.c
CommitLineData
4b88f280 1#line 2 "op.c"
a0d0e21e 2/* op.c
79072805 3 *
1129b882
NC		 4 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
5 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
79072805
LW		 6 *
7 * You may distribute under the terms of either the GNU General Public
8 * License or the Artistic License, as specified in the README file.
9 *
a0d0e21e
LW		 10 */
11
12/*
4ac71550
TC		 13 * 'You see: Mr. Drogo, he married poor Miss Primula Brandybuck. She was
14 * our Mr. Bilbo's first cousin on the mother's side (her mother being the
15 * youngest of the Old Took's daughters); and Mr. Drogo was his second
16 * cousin. So Mr. Frodo is his first *and* second cousin, once removed
17 * either way, as the saying is, if you follow me.' --the Gaffer
18 *
19 * [p.23 of _The Lord of the Rings_, I/i: "A Long-Expected Party"]
79072805
LW		 20 */
21
166f8a29
DM		 22/* This file contains the functions that create, manipulate and optimize
23 * the OP structures that hold a compiled perl program.
24 *
25 * A Perl program is compiled into a tree of OPs. Each op contains
26 * structural pointers (eg to its siblings and the next op in the
27 * execution sequence), a pointer to the function that would execute the
28 * op, plus any data specific to that op. For example, an OP_CONST op
29 * points to the pp_const() function and to an SV containing the constant
30 * value. When pp_const() is executed, its job is to push that SV onto the
31 * stack.
32 *
33 * OPs are mainly created by the newFOO() functions, which are mainly
34 * called from the parser (in perly.y) as the code is parsed. For example
35 * the Perl code $a + $b * $c would cause the equivalent of the following
36 * to be called (oversimplifying a bit):
37 *
38 * newBINOP(OP_ADD, flags,
39 * newSVREF($a),
40 * newBINOP(OP_MULTIPLY, flags, newSVREF($b), newSVREF($c))
41 * )
42 *
43 * Note that during the build of miniperl, a temporary copy of this file
44 * is made, called opmini.c.
45 */
ccfc67b7 46
61b743bb
DM		 47/*
48Perl's compiler is essentially a 3-pass compiler with interleaved phases:
49
50 A bottom-up pass
51 A top-down pass
52 An execution-order pass
53
54The bottom-up pass is represented by all the "newOP" routines and
55the ck_ routines. The bottom-upness is actually driven by yacc.
56So at the point that a ck_ routine fires, we have no idea what the
57context is, either upward in the syntax tree, or either forward or
58backward in the execution order. (The bottom-up parser builds that
59part of the execution order it knows about, but if you follow the "next"
60links around, you'll find it's actually a closed loop through the
ef9da979 61top level node.)
61b743bb
DM		 62
63Whenever the bottom-up parser gets to a node that supplies context to
64its components, it invokes that portion of the top-down pass that applies
65to that part of the subtree (and marks the top node as processed, so
66if a node further up supplies context, it doesn't have to take the
67plunge again). As a particular subcase of this, as the new node is
68built, it takes all the closed execution loops of its subcomponents
69and links them into a new closed loop for the higher level node. But
70it's still not the real execution order.
71
72The actual execution order is not known till we get a grammar reduction
73to a top-level unit like a subroutine or file that will be called by
74"name" rather than via a "next" pointer. At that point, we can call
75into peep() to do that code's portion of the 3rd pass. It has to be
76recursive, but it's recursive on basic blocks, not on tree nodes.
77*/
78
06e0342d 79/* To implement user lexical pragmas, there needs to be a way at run time to
b3ca2e83
NC		 80 get the compile time state of %^H for that block. Storing %^H in every
81 block (or even COP) would be very expensive, so a different approach is
82 taken. The (running) state of %^H is serialised into a tree of HE-like
83 structs. Stores into %^H are chained onto the current leaf as a struct
84 refcounted_he * with the key and the value. Deletes from %^H are saved
85 with a value of PL_sv_placeholder. The state of %^H at any point can be
86 turned back into a regular HV by walking back up the tree from that point's
06e0342d 87 leaf, ignoring any key you've already seen (placeholder or not), storing
b3ca2e83
NC		 88 the rest into the HV structure, then removing the placeholders. Hence
89 memory is only used to store the %^H deltas from the enclosing COP, rather
90 than the entire %^H on each COP.
91
92 To cause actions on %^H to write out the serialisation records, it has
93 magic type 'H'. This magic (itself) does nothing, but its presence causes
94 the values to gain magic type 'h', which has entries for set and clear.
c28fe1ec 95 C<Perl_magic_sethint> updates C<PL_compiling.cop_hints_hash> with a store
34795b44 96 record, with deletes written by C<Perl_magic_clearhint>. C<SAVEHINTS>
c28fe1ec
NC		 97 saves the current C<PL_compiling.cop_hints_hash> on the save stack, so that
98 it will be correctly restored when any inner compiling scope is exited.
b3ca2e83
NC		 99*/
100
79072805 101#include "EXTERN.h"
864dbfa3 102#define PERL_IN_OP_C
79072805 103#include "perl.h"
77ca0c92 104#include "keywords.h"
79072805 105
16c91539 106#define CALL_PEEP(o) PL_peepp(aTHX_ o)
1a0a2ba9 107#define CALL_RPEEP(o) PL_rpeepp(aTHX_ o)
16c91539 108#define CALL_OPFREEHOOK(o) if (PL_opfreehook) PL_opfreehook(aTHX_ o)
a2efc822 109
238a4c30
NIS		 110#if defined(PL_OP_SLAB_ALLOC)
111
f1fac472
NC		 112#ifdef PERL_DEBUG_READONLY_OPS
113# define PERL_SLAB_SIZE 4096
114# include <sys/mman.h>
115#endif
116
238a4c30
NIS		 117#ifndef PERL_SLAB_SIZE
118#define PERL_SLAB_SIZE 2048
119#endif
120
c7e45529 121void *
e91d68d5 122Perl_Slab_Alloc(pTHX_ size_t sz)
1c846c1f 123{
5186cc12 124 dVAR;
5a8e194f
NIS		 125 /*
126 * To make incrementing use count easy PL_OpSlab is an I32 *
127 * To make inserting the link to slab PL_OpPtr is I32 **
128 * So compute size in units of sizeof(I32 *) as that is how Pl_OpPtr increments
129 * Add an overhead for pointer to slab and round up as a number of pointers
130 */
131 sz = (sz + 2*sizeof(I32 *) -1)/sizeof(I32 *);
238a4c30 132 if ((PL_OpSpace -= sz) < 0) {
f1fac472
NC		 133#ifdef PERL_DEBUG_READONLY_OPS
134 /* We need to allocate chunk by chunk so that we can control the VM
135 mapping */
5186cc12 136 PL_OpPtr = (I32**) mmap(0, PERL_SLAB_SIZE*sizeof(I32*), PROT_READ|PROT_WRITE,
f1fac472
NC		 137 MAP_ANON|MAP_PRIVATE, -1, 0);
138
139 DEBUG_m(PerlIO_printf(Perl_debug_log, "mapped %lu at %p\n",
140 (unsigned long) PERL_SLAB_SIZE*sizeof(I32*),
141 PL_OpPtr));
142 if(PL_OpPtr == MAP_FAILED) {
143 perror("mmap failed");
144 abort();
145 }
146#else
277e868c
NC		 147
148 PL_OpPtr = (I32 **) PerlMemShared_calloc(PERL_SLAB_SIZE,sizeof(I32*));
f1fac472 149#endif
083fcd59 150 if (!PL_OpPtr) {
238a4c30
NIS		 151 return NULL;
152 }
5a8e194f
NIS		 153 /* We reserve the 0'th I32 sized chunk as a use count */
154 PL_OpSlab = (I32 *) PL_OpPtr;
155 /* Reduce size by the use count word, and by the size we need.
156 * Latter is to mimic the '-=' in the if() above
157 */
158 PL_OpSpace = PERL_SLAB_SIZE - (sizeof(I32)+sizeof(I32 **)-1)/sizeof(I32 **) - sz;
238a4c30
NIS		 159 /* Allocation pointer starts at the top.
160 Theory: because we build leaves before trunk allocating at end
161 means that at run time access is cache friendly upward
162 */
5a8e194f 163 PL_OpPtr += PERL_SLAB_SIZE;
f1fac472
NC		 164
165#ifdef PERL_DEBUG_READONLY_OPS
166 /* We remember this slab. */
167 /* This implementation isn't efficient, but it is simple. */
5186cc12 168 PL_slabs = (I32**) realloc(PL_slabs, sizeof(I32**) * (PL_slab_count + 1));
f1fac472
NC		 169 PL_slabs[PL_slab_count++] = PL_OpSlab;
170 DEBUG_m(PerlIO_printf(Perl_debug_log, "Allocate %p\n", PL_OpSlab));
171#endif
238a4c30
NIS		 172 }
173 assert( PL_OpSpace >= 0 );
174 /* Move the allocation pointer down */
175 PL_OpPtr -= sz;
5a8e194f 176 assert( PL_OpPtr > (I32 **) PL_OpSlab );
238a4c30
NIS		 177 *PL_OpPtr = PL_OpSlab; /* Note which slab it belongs to */
178 (*PL_OpSlab)++; /* Increment use count of slab */
5a8e194f 179 assert( PL_OpPtr+sz <= ((I32 **) PL_OpSlab + PERL_SLAB_SIZE) );
238a4c30
NIS		 180 assert( *PL_OpSlab > 0 );
181 return (void *)(PL_OpPtr + 1);
182}
183
f1fac472
NC		 184#ifdef PERL_DEBUG_READONLY_OPS
185void
186Perl_pending_Slabs_to_ro(pTHX) {
187 /* Turn all the allocated op slabs read only. */
188 U32 count = PL_slab_count;
189 I32 **const slabs = PL_slabs;
190
191 /* Reset the array of pending OP slabs, as we're about to turn this lot
192 read only. Also, do it ahead of the loop in case the warn triggers,
193 and a warn handler has an eval */
194
f1fac472
NC		 195 PL_slabs = NULL;
196 PL_slab_count = 0;
197
198 /* Force a new slab for any further allocation. */
199 PL_OpSpace = 0;
200
201 while (count--) {
5892a4d4 202 void *const start = slabs[count];
f1fac472
NC		 203 const size_t size = PERL_SLAB_SIZE* sizeof(I32*);
204 if(mprotect(start, size, PROT_READ)) {
205 Perl_warn(aTHX_ "mprotect for %p %lu failed with %d",
206 start, (unsigned long) size, errno);
207 }
208 }
5892a4d4
NC		 209
210 free(slabs);
f1fac472
NC		 211}
212
213STATIC void
214S_Slab_to_rw(pTHX_ void *op)
215{
216 I32 * const * const ptr = (I32 **) op;
217 I32 * const slab = ptr[-1];
7918f24d
NC		 218
219 PERL_ARGS_ASSERT_SLAB_TO_RW;
220
f1fac472
NC		 221 assert( ptr-1 > (I32 **) slab );
222 assert( ptr < ( (I32 **) slab + PERL_SLAB_SIZE) );
223 assert( *slab > 0 );
224 if(mprotect(slab, PERL_SLAB_SIZE*sizeof(I32*), PROT_READ|PROT_WRITE)) {
225 Perl_warn(aTHX_ "mprotect RW for %p %lu failed with %d",
226 slab, (unsigned long) PERL_SLAB_SIZE*sizeof(I32*), errno);
227 }
228}
fc97af9c
NC		 229
230OP *
231Perl_op_refcnt_inc(pTHX_ OP *o)
232{
233 if(o) {
234 Slab_to_rw(o);
235 ++o->op_targ;
236 }
237 return o;
238
239}
240
241PADOFFSET
242Perl_op_refcnt_dec(pTHX_ OP *o)
243{
7918f24d 244 PERL_ARGS_ASSERT_OP_REFCNT_DEC;
fc97af9c
NC		 245 Slab_to_rw(o);
246 return --o->op_targ;
247}
f1fac472
NC		 248#else
249# define Slab_to_rw(op)
250#endif
251
c7e45529
AE		 252void
253Perl_Slab_Free(pTHX_ void *op)
238a4c30 254{
551405c4 255 I32 * const * const ptr = (I32 **) op;
aec46f14 256 I32 * const slab = ptr[-1];
7918f24d 257 PERL_ARGS_ASSERT_SLAB_FREE;
5a8e194f
NIS		 258 assert( ptr-1 > (I32 **) slab );
259 assert( ptr < ( (I32 **) slab + PERL_SLAB_SIZE) );
238a4c30 260 assert( *slab > 0 );
f1fac472 261 Slab_to_rw(op);
238a4c30 262 if (--(*slab) == 0) {
7e4e8c89
NC		 263# ifdef NETWARE
264# define PerlMemShared PerlMem
265# endif
083fcd59 266
f1fac472 267#ifdef PERL_DEBUG_READONLY_OPS
782a40f1 268 U32 count = PL_slab_count;
f1fac472 269 /* Need to remove this slab from our list of slabs */
782a40f1 270 if (count) {
f1fac472
NC		 271 while (count--) {
272 if (PL_slabs[count] == slab) {
5186cc12 273 dVAR;
f1fac472
NC		 274 /* Found it. Move the entry at the end to overwrite it. */
275 DEBUG_m(PerlIO_printf(Perl_debug_log,
276 "Deallocate %p by moving %p from %lu to %lu\n",
277 PL_OpSlab,
278 PL_slabs[PL_slab_count - 1],
279 PL_slab_count, count));
280 PL_slabs[count] = PL_slabs[--PL_slab_count];
281 /* Could realloc smaller at this point, but probably not
282 worth it. */
fc97af9c
NC		 283 if(munmap(slab, PERL_SLAB_SIZE*sizeof(I32*))) {
284 perror("munmap failed");
285 abort();
286 }
287 break;
f1fac472 288 }
f1fac472
NC		 289 }
290 }
291#else
083fcd59 292 PerlMemShared_free(slab);
f1fac472 293#endif
238a4c30
NIS		 294 if (slab == PL_OpSlab) {
295 PL_OpSpace = 0;
296 }
297 }
b7dc083c 298}
b7dc083c 299#endif
e50aee73 300/*
ce6f1cbc 301 * In the following definition, the ", (OP*)0" is just to make the compiler
a5f75d66 302 * think the expression is of the right type: croak actually does a Siglongjmp.
e50aee73 303 */
11343788 304#define CHECKOP(type,o) \
ce6f1cbc 305 ((PL_op_mask && PL_op_mask[type]) \
5dc0d613 306 ? ( op_free((OP*)o), \
cb77fdf0 307 Perl_croak(aTHX_ "'%s' trapped by operation mask", PL_op_desc[type]), \
ce6f1cbc 308 (OP*)0 ) \
16c91539 309 : PL_check[type](aTHX_ (OP*)o))
e50aee73 310
e6438c1a 311#define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
c53d7c7d 312
cba5a3b0
DG		 313#define CHANGE_TYPE(o,type) \
314 STMT_START { \
315 o->op_type = (OPCODE)type; \
316 o->op_ppaddr = PL_ppaddr[type]; \
317 } STMT_END
318
8b6b16e7 319STATIC const char*
cea2e8a9 320S_gv_ename(pTHX_ GV *gv)
4633a7c4 321{
46c461b5 322 SV* const tmpsv = sv_newmortal();
7918f24d
NC		 323
324 PERL_ARGS_ASSERT_GV_ENAME;
325
bd61b366 326 gv_efullname3(tmpsv, gv, NULL);
8b6b16e7 327 return SvPV_nolen_const(tmpsv);
4633a7c4
LW		 328}
329
76e3520e 330STATIC OP *
cea2e8a9 331S_no_fh_allowed(pTHX_ OP *o)
79072805 332{
7918f24d
NC		 333 PERL_ARGS_ASSERT_NO_FH_ALLOWED;
334
cea2e8a9 335 yyerror(Perl_form(aTHX_ "Missing comma after first argument to %s function",
53e06cf0 336 OP_DESC(o)));
11343788 337 return o;
79072805
LW		 338}
339
76e3520e 340STATIC OP *
bfed75c6 341S_too_few_arguments(pTHX_ OP *o, const char *name)
79072805 342{
7918f24d
NC		 343 PERL_ARGS_ASSERT_TOO_FEW_ARGUMENTS;
344
cea2e8a9 345 yyerror(Perl_form(aTHX_ "Not enough arguments for %s", name));
11343788 346 return o;
79072805
LW		 347}
348
76e3520e 349STATIC OP *
bfed75c6 350S_too_many_arguments(pTHX_ OP *o, const char *name)
79072805 351{
7918f24d
NC		 352 PERL_ARGS_ASSERT_TOO_MANY_ARGUMENTS;
353
cea2e8a9 354 yyerror(Perl_form(aTHX_ "Too many arguments for %s", name));
11343788 355 return o;
79072805
LW		 356}
357
76e3520e 358STATIC void
6867be6d 359S_bad_type(pTHX_ I32 n, const char *t, const char *name, const OP *kid)
8990e307 360{
7918f24d
NC		 361 PERL_ARGS_ASSERT_BAD_TYPE;
362
cea2e8a9 363 yyerror(Perl_form(aTHX_ "Type of arg %d to %s must be %s (not %s)",
53e06cf0 364 (int)n, name, t, OP_DESC(kid)));
8990e307
LW		 365}
366
7a52d87a 367STATIC void
6867be6d 368S_no_bareword_allowed(pTHX_ const OP *o)
7a52d87a 369{
7918f24d
NC		 370 PERL_ARGS_ASSERT_NO_BAREWORD_ALLOWED;
371
eb8433b7
NC		 372 if (PL_madskills)
373 return; /* various ok barewords are hidden in extra OP_NULL */
5a844595 374 qerror(Perl_mess(aTHX_
35c1215d 375 "Bareword \"%"SVf"\" not allowed while \"strict subs\" in use",
be2597df 376 SVfARG(cSVOPo_sv)));
7a52d87a
GS		 377}
378
79072805
LW		 379/* "register" allocation */
380
381PADOFFSET
d6447115 382Perl_allocmy(pTHX_ const char *const name, const STRLEN len, const U32 flags)
93a17b20 383{
97aff369 384 dVAR;
a0d0e21e 385 PADOFFSET off;
12bd6ede 386 const bool is_our = (PL_parser->in_my == KEY_our);
a0d0e21e 387
7918f24d
NC		 388 PERL_ARGS_ASSERT_ALLOCMY;
389
d6447115
NC		 390 if (flags)
391 Perl_croak(aTHX_ "panic: allocmy illegal flag bits 0x%" UVxf,
392 (UV)flags);
393
394 /* Until we're using the length for real, cross check that we're being
395 told the truth. */
396 assert(strlen(name) == len);
397
59f00321 398 /* complain about "my $<special_var>" etc etc */
d6447115 399 if (len &&
3edf23ff 400 !(is_our ||
155aba94 401 isALPHA(name[1]) ||
39e02b42 402 (USE_UTF8_IN_NAMES && UTF8_IS_START(name[1])) ||
d6447115 403 (name[1] == '_' && (*name == '$' || len > 2))))
834a4ddd 404 {
6b58708b 405 /* name[2] is true if strlen(name) > 2 */
c4d0567e 406 if (!isPRINT(name[1]) || strchr("\t\n\r\f", name[1])) {
d6447115
NC		 407 yyerror(Perl_form(aTHX_ "Can't use global %c^%c%.*s in \"%s\"",
408 name[0], toCTRL(name[1]), (int)(len - 2), name + 2,
aab6a793 409 PL_parser->in_my == KEY_state ? "state" : "my"));
d1544d85 410 } else {
d6447115 411 yyerror(Perl_form(aTHX_ "Can't use global %.*s in \"%s\"", (int) len, name,
aab6a793 412 PL_parser->in_my == KEY_state ? "state" : "my"));
46fc3d4c 413 }
a0d0e21e 414 }
748a9306 415
dd2155a4 416 /* allocate a spare slot and store the name in that slot */
93a17b20 417
cca43f78 418 off = pad_add_name(name, len,
59cfed7d
NC		 419 is_our ? padadd_OUR :
420 PL_parser->in_my == KEY_state ? padadd_STATE : 0,
12bd6ede 421 PL_parser->in_my_stash,
3edf23ff 422 (is_our
133706a6
RGS		 423 /* $_ is always in main::, even with our */
424 ? (PL_curstash && !strEQ(name,"$_") ? PL_curstash : PL_defstash)
5c284bb0 425 : NULL
cca43f78 426 )
dd2155a4 427 );
a74073ad
DM		 428 /* anon sub prototypes contains state vars should always be cloned,
429 * otherwise the state var would be shared between anon subs */
430
431 if (PL_parser->in_my == KEY_state && CvANON(PL_compcv))
432 CvCLONE_on(PL_compcv);
433
dd2155a4 434 return off;
79072805
LW		 435}
436
d2c837a0
DM		 437/* free the body of an op without examining its contents.
438 * Always use this rather than FreeOp directly */
439
4136a0f7 440static void
d2c837a0
DM		 441S_op_destroy(pTHX_ OP *o)
442{
443 if (o->op_latefree) {
444 o->op_latefreed = 1;
445 return;
446 }
447 FreeOp(o);
448}
449
c4bd3ae5
NC		 450#ifdef USE_ITHREADS
451# define forget_pmop(a,b) S_forget_pmop(aTHX_ a,b)
452#else
453# define forget_pmop(a,b) S_forget_pmop(aTHX_ a)
454#endif
d2c837a0 455
79072805
LW		 456/* Destructor */
457
458void
864dbfa3 459Perl_op_free(pTHX_ OP *o)
79072805 460{
27da23d5 461 dVAR;
acb36ea4 462 OPCODE type;
79072805 463
85594c31 464 if (!o)
79072805 465 return;
670f3923
DM		 466 if (o->op_latefreed) {
467 if (o->op_latefree)
468 return;
469 goto do_free;
470 }
79072805 471
67566ccd 472 type = o->op_type;
7934575e 473 if (o->op_private & OPpREFCOUNTED) {
67566ccd 474 switch (type) {
7934575e
GS		 475 case OP_LEAVESUB:
476 case OP_LEAVESUBLV:
477 case OP_LEAVEEVAL:
478 case OP_LEAVE:
479 case OP_SCOPE:
480 case OP_LEAVEWRITE:
67566ccd
AL		 481 {
482 PADOFFSET refcnt;
7934575e 483 OP_REFCNT_LOCK;
4026c95a 484 refcnt = OpREFCNT_dec(o);
7934575e 485 OP_REFCNT_UNLOCK;
bfd0ff22
NC		 486 if (refcnt) {
487 /* Need to find and remove any pattern match ops from the list
488 we maintain for reset(). */
489 find_and_forget_pmops(o);
4026c95a 490 return;
67566ccd 491 }
bfd0ff22 492 }
7934575e
GS		 493 break;
494 default:
495 break;
496 }
497 }
498
f37b8c3f
VP		 499 /* Call the op_free hook if it has been set. Do it now so that it's called
500 * at the right time for refcounted ops, but still before all of the kids
501 * are freed. */
502 CALL_OPFREEHOOK(o);
503
11343788 504 if (o->op_flags & OPf_KIDS) {
6867be6d 505 register OP *kid, *nextkid;
11343788 506 for (kid = cUNOPo->op_first; kid; kid = nextkid) {
85e6fe83 507 nextkid = kid->op_sibling; /* Get before next freeing kid */
79072805 508 op_free(kid);
85e6fe83 509 }
79072805 510 }
acb36ea4 511
fc97af9c
NC		 512#ifdef PERL_DEBUG_READONLY_OPS
513 Slab_to_rw(o);
514#endif
515
acb36ea4
GS		 516 /* COP* is not cleared by op_clear() so that we may track line
517 * numbers etc even after null() */
cc93af5f
RGS		 518 if (type == OP_NEXTSTATE || type == OP_DBSTATE
519 || (type == OP_NULL /* the COP might have been null'ed */
520 && ((OPCODE)o->op_targ == OP_NEXTSTATE
521 || (OPCODE)o->op_targ == OP_DBSTATE))) {
acb36ea4 522 cop_free((COP*)o);
3235b7a3 523 }
acb36ea4 524
c53f1caa
RU		 525 if (type == OP_NULL)
526 type = (OPCODE)o->op_targ;
527
acb36ea4 528 op_clear(o);
670f3923
DM		 529 if (o->op_latefree) {
530 o->op_latefreed = 1;
531 return;
532 }
533 do_free:
238a4c30 534 FreeOp(o);
4d494880
DM		 535#ifdef DEBUG_LEAKING_SCALARS
536 if (PL_op == o)
5f66b61c 537 PL_op = NULL;
4d494880 538#endif
acb36ea4 539}
79072805 540
93c66552
DM		 541void
542Perl_op_clear(pTHX_ OP *o)
acb36ea4 543{
13137afc 544
27da23d5 545 dVAR;
7918f24d
NC		 546
547 PERL_ARGS_ASSERT_OP_CLEAR;
548
eb8433b7
NC		 549#ifdef PERL_MAD
550 /* if (o->op_madprop && o->op_madprop->mad_next)
551 abort(); */
3cc8d589
NC		 552 /* FIXME for MAD - if I uncomment these two lines t/op/pack.t fails with
553 "modification of a read only value" for a reason I can't fathom why.
554 It's the "" stringification of $_, where $_ was set to '' in a foreach
04a4d38e
NC		 555 loop, but it defies simplification into a small test case.
556 However, commenting them out has caused ext/List/Util/t/weak.t to fail
557 the last test. */
3cc8d589
NC		 558 /*
559 mad_free(o->op_madprop);
560 o->op_madprop = 0;
561 */
eb8433b7
NC		 562#endif
563
564 retry:
11343788 565 switch (o->op_type) {
acb36ea4 566 case OP_NULL: /* Was holding old type, if any. */
eb8433b7 567 if (PL_madskills && o->op_targ != OP_NULL) {
61a59f30 568 o->op_type = (Optype)o->op_targ;
eb8433b7
NC		 569 o->op_targ = 0;
570 goto retry;
571 }
4d193d44 572 case OP_ENTERTRY:
acb36ea4 573 case OP_ENTEREVAL: /* Was holding hints. */
acb36ea4 574 o->op_targ = 0;
a0d0e21e 575 break;
a6006777 576 default:
ac4c12e7 577 if (!(o->op_flags & OPf_REF)
ef69c8fc 578 || (PL_check[o->op_type] != Perl_ck_ftst))
a6006777 579 break;
580 /* FALL THROUGH */
463ee0b2 581 case OP_GVSV:
79072805 582 case OP_GV:
a6006777 583 case OP_AELEMFAST:
6a077020
DM		 584 if (! (o->op_type == OP_AELEMFAST && o->op_flags & OPf_SPECIAL)) {
585 /* not an OP_PADAV replacement */
f7461760
Z		 586 GV *gv = (o->op_type == OP_GV || o->op_type == OP_GVSV)
587#ifdef USE_ITHREADS
588 && PL_curpad
589#endif
590 ? cGVOPo_gv : NULL;
b327b36f
NC		 591 /* It's possible during global destruction that the GV is freed
592 before the optree. Whilst the SvREFCNT_inc is happy to bump from
593 0 to 1 on a freed SV, the corresponding SvREFCNT_dec from 1 to 0
594 will trigger an assertion failure, because the entry to sv_clear
595 checks that the scalar is not already freed. A check of for
596 !SvIS_FREED(gv) turns out to be invalid, because during global
597 destruction the reference count can be forced down to zero
598 (with SVf_BREAK set). In which case raising to 1 and then
599 dropping to 0 triggers cleanup before it should happen. I
600 *think* that this might actually be a general, systematic,
601 weakness of the whole idea of SVf_BREAK, in that code *is*
602 allowed to raise and lower references during global destruction,
603 so any *valid* code that happens to do this during global
604 destruction might well trigger premature cleanup. */
605 bool still_valid = gv && SvREFCNT(gv);
606
607 if (still_valid)
608 SvREFCNT_inc_simple_void(gv);
350de78d 609#ifdef USE_ITHREADS
6a077020
DM		 610 if (cPADOPo->op_padix > 0) {
611 /* No GvIN_PAD_off(cGVOPo_gv) here, because other references
612 * may still exist on the pad */
613 pad_swipe(cPADOPo->op_padix, TRUE);
614 cPADOPo->op_padix = 0;
615 }
350de78d 616#else
6a077020 617 SvREFCNT_dec(cSVOPo->op_sv);
a0714e2c 618 cSVOPo->op_sv = NULL;
350de78d 619#endif
b327b36f 620 if (still_valid) {
f7461760
Z		 621 int try_downgrade = SvREFCNT(gv) == 2;
622 SvREFCNT_dec(gv);
623 if (try_downgrade)
624 gv_try_downgrade(gv);
625 }
6a077020 626 }
79072805 627 break;
a1ae71d2 628 case OP_METHOD_NAMED:
79072805 629 case OP_CONST:
996c9baa 630 case OP_HINTSEVAL:
11343788 631 SvREFCNT_dec(cSVOPo->op_sv);
a0714e2c 632 cSVOPo->op_sv = NULL;
3b1c21fa
AB		 633#ifdef USE_ITHREADS
634 /** Bug #15654
635 Even if op_clear does a pad_free for the target of the op,
6a077020 636 pad_free doesn't actually remove the sv that exists in the pad;
3b1c21fa
AB		 637 instead it lives on. This results in that it could be reused as
638 a target later on when the pad was reallocated.
639 **/
640 if(o->op_targ) {
641 pad_swipe(o->op_targ,1);
642 o->op_targ = 0;
643 }
644#endif
79072805 645 break;
748a9306
LW		 646 case OP_GOTO:
647 case OP_NEXT:
648 case OP_LAST:
649 case OP_REDO:
11343788 650 if (o->op_flags & (OPf_SPECIAL|OPf_STACKED|OPf_KIDS))
748a9306
LW		 651 break;
652 /* FALL THROUGH */
a0d0e21e 653 case OP_TRANS:
bb16bae8 654 case OP_TRANSR:
acb36ea4 655 if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
043e41b8
DM		 656#ifdef USE_ITHREADS
657 if (cPADOPo->op_padix > 0) {
658 pad_swipe(cPADOPo->op_padix, TRUE);
659 cPADOPo->op_padix = 0;
660 }
661#else
a0ed51b3 662 SvREFCNT_dec(cSVOPo->op_sv);
a0714e2c 663 cSVOPo->op_sv = NULL;
043e41b8 664#endif
acb36ea4
GS		 665 }
666 else {
ea71c68d 667 PerlMemShared_free(cPVOPo->op_pv);
bd61b366 668 cPVOPo->op_pv = NULL;
acb36ea4 669 }
a0d0e21e
LW		 670 break;
671 case OP_SUBST:
20e98b0f 672 op_free(cPMOPo->op_pmreplrootu.op_pmreplroot);
971a9dd3 673 goto clear_pmop;
748a9306 674 case OP_PUSHRE:
971a9dd3 675#ifdef USE_ITHREADS
20e98b0f 676 if (cPMOPo->op_pmreplrootu.op_pmtargetoff) {
dd2155a4
DM		 677 /* No GvIN_PAD_off here, because other references may still
678 * exist on the pad */
20e98b0f 679 pad_swipe(cPMOPo->op_pmreplrootu.op_pmtargetoff, TRUE);
971a9dd3
GS		 680 }
681#else
ad64d0ec 682 SvREFCNT_dec(MUTABLE_SV(cPMOPo->op_pmreplrootu.op_pmtargetgv));
971a9dd3
GS		 683#endif
684 /* FALL THROUGH */
a0d0e21e 685 case OP_MATCH:
8782bef2 686 case OP_QR:
971a9dd3 687clear_pmop:
c2b1997a 688 forget_pmop(cPMOPo, 1);
20e98b0f 689 cPMOPo->op_pmreplrootu.op_pmreplroot = NULL;
9cddf794
NC		 690 /* we use the same protection as the "SAFE" version of the PM_ macros
691 * here since sv_clean_all might release some PMOPs
5f8cb046
DM		 692 * after PL_regex_padav has been cleared
693 * and the clearing of PL_regex_padav needs to
694 * happen before sv_clean_all
695 */
13137afc
AB		 696#ifdef USE_ITHREADS
697 if(PL_regex_pad) { /* We could be in destruction */
402d2eb1 698 const IV offset = (cPMOPo)->op_pmoffset;
9cddf794 699 ReREFCNT_dec(PM_GETRE(cPMOPo));
402d2eb1
NC		 700 PL_regex_pad[offset] = &PL_sv_undef;
701 sv_catpvn_nomg(PL_regex_pad[0], (const char *)&offset,
702 sizeof(offset));
13137afc 703 }
9cddf794
NC		 704#else
705 ReREFCNT_dec(PM_GETRE(cPMOPo));
706 PM_SETRE(cPMOPo, NULL);
1eb1540c 707#endif
13137afc 708
a0d0e21e 709 break;
79072805
LW		 710 }
711
743e66e6 712 if (o->op_targ > 0) {
11343788 713 pad_free(o->op_targ);
743e66e6
GS		 714 o->op_targ = 0;
715 }
79072805
LW		 716}
717
76e3520e 718STATIC void
3eb57f73
HS		 719S_cop_free(pTHX_ COP* cop)
720{
7918f24d
NC		 721 PERL_ARGS_ASSERT_COP_FREE;
722
05ec9bb3
NIS		 723 CopFILE_free(cop);
724 CopSTASH_free(cop);
0453d815 725 if (! specialWARN(cop->cop_warnings))
72dc9ed5 726 PerlMemShared_free(cop->cop_warnings);
20439bc7 727 cophh_free(CopHINTHASH_get(cop));
3eb57f73
HS		 728}
729
c2b1997a 730STATIC void
c4bd3ae5
NC		 731S_forget_pmop(pTHX_ PMOP *const o
732#ifdef USE_ITHREADS
733 , U32 flags
734#endif
735 )
c2b1997a
NC		 736{
737 HV * const pmstash = PmopSTASH(o);
7918f24d
NC		 738
739 PERL_ARGS_ASSERT_FORGET_PMOP;
740
c2b1997a 741 if (pmstash && !SvIS_FREED(pmstash)) {
ad64d0ec 742 MAGIC * const mg = mg_find((const SV *)pmstash, PERL_MAGIC_symtab);
c2b1997a
NC		 743 if (mg) {
744 PMOP **const array = (PMOP**) mg->mg_ptr;
745 U32 count = mg->mg_len / sizeof(PMOP**);
746 U32 i = count;
747
748 while (i--) {
749 if (array[i] == o) {
750 /* Found it. Move the entry at the end to overwrite it. */
751 array[i] = array[--count];
752 mg->mg_len = count * sizeof(PMOP**);
753 /* Could realloc smaller at this point always, but probably
754 not worth it. Probably worth free()ing if we're the
755 last. */
756 if(!count) {
757 Safefree(mg->mg_ptr);
758 mg->mg_ptr = NULL;
759 }
760 break;
761 }
762 }
763 }
764 }
1cdf7faf
NC		 765 if (PL_curpm == o)
766 PL_curpm = NULL;
c4bd3ae5 767#ifdef USE_ITHREADS
c2b1997a
NC		 768 if (flags)
769 PmopSTASH_free(o);
c4bd3ae5 770#endif
c2b1997a
NC		 771}
772
bfd0ff22
NC		 773STATIC void
774S_find_and_forget_pmops(pTHX_ OP *o)
775{
7918f24d
NC		 776 PERL_ARGS_ASSERT_FIND_AND_FORGET_PMOPS;
777
bfd0ff22
NC		 778 if (o->op_flags & OPf_KIDS) {
779 OP *kid = cUNOPo->op_first;
780 while (kid) {
781 switch (kid->op_type) {
782 case OP_SUBST:
783 case OP_PUSHRE:
784 case OP_MATCH:
785 case OP_QR:
786 forget_pmop((PMOP*)kid, 0);
787 }
788 find_and_forget_pmops(kid);
789 kid = kid->op_sibling;
790 }
791 }
792}
793
93c66552
DM		 794void
795Perl_op_null(pTHX_ OP *o)
8990e307 796{
27da23d5 797 dVAR;
7918f24d
NC		 798
799 PERL_ARGS_ASSERT_OP_NULL;
800
acb36ea4
GS		 801 if (o->op_type == OP_NULL)
802 return;
eb8433b7
NC		 803 if (!PL_madskills)
804 op_clear(o);
11343788
MB		 805 o->op_targ = o->op_type;
806 o->op_type = OP_NULL;
22c35a8c 807 o->op_ppaddr = PL_ppaddr[OP_NULL];
8990e307
LW		 808}
809
4026c95a
SH		 810void
811Perl_op_refcnt_lock(pTHX)
812{
27da23d5 813 dVAR;
96a5add6 814 PERL_UNUSED_CONTEXT;
4026c95a
SH		 815 OP_REFCNT_LOCK;
816}
817
818void
819Perl_op_refcnt_unlock(pTHX)
820{
27da23d5 821 dVAR;
96a5add6 822 PERL_UNUSED_CONTEXT;
4026c95a
SH		 823 OP_REFCNT_UNLOCK;
824}
825
79072805
LW		 826/* Contextualizers */
827
d9088386
Z		 828/*
829=for apidoc Am|OP *|op_contextualize|OP *o|I32 context
830
831Applies a syntactic context to an op tree representing an expression.
832I<o> is the op tree, and I<context> must be C<G_SCALAR>, C<G_ARRAY>,
833or C<G_VOID> to specify the context to apply. The modified op tree
834is returned.
835
836=cut
837*/
838
839OP *
840Perl_op_contextualize(pTHX_ OP *o, I32 context)
841{
842 PERL_ARGS_ASSERT_OP_CONTEXTUALIZE;
843 switch (context) {
844 case G_SCALAR: return scalar(o);
845 case G_ARRAY: return list(o);
846 case G_VOID: return scalarvoid(o);
847 default:
848 Perl_croak(aTHX_ "panic: op_contextualize bad context");
849 return o;
850 }
851}
852
5983a79d
BM		 853/*
854=head1 Optree Manipulation Functions
79072805 855
5983a79d
BM		 856=for apidoc Am|OP*|op_linklist|OP *o
857This function is the implementation of the L</LINKLIST> macro. It should
858not be called directly.
859
860=cut
861*/
862
863OP *
864Perl_op_linklist(pTHX_ OP *o)
79072805 865{
3edf23ff 866 OP *first;
79072805 867
5983a79d 868 PERL_ARGS_ASSERT_OP_LINKLIST;
7918f24d 869
11343788
MB		 870 if (o->op_next)
871 return o->op_next;
79072805
LW		 872
873 /* establish postfix order */
3edf23ff
AL		 874 first = cUNOPo->op_first;
875 if (first) {
6867be6d 876 register OP *kid;
3edf23ff
AL		 877 o->op_next = LINKLIST(first);
878 kid = first;
879 for (;;) {
880 if (kid->op_sibling) {
79072805 881 kid->op_next = LINKLIST(kid->op_sibling);
3edf23ff
AL		 882 kid = kid->op_sibling;
883 } else {
11343788 884 kid->op_next = o;
3edf23ff
AL		 885 break;
886 }
79072805
LW		 887 }
888 }
889 else
11343788 890 o->op_next = o;
79072805 891
11343788 892 return o->op_next;
79072805
LW		 893}
894
1f676739 895static OP *
2dd5337b 896S_scalarkids(pTHX_ OP *o)
79072805 897{
11343788 898 if (o && o->op_flags & OPf_KIDS) {
bfed75c6 899 OP *kid;
11343788 900 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW		 901 scalar(kid);
902 }
11343788 903 return o;
79072805
LW		 904}
905
76e3520e 906STATIC OP *
cea2e8a9 907S_scalarboolean(pTHX_ OP *o)
8990e307 908{
97aff369 909 dVAR;
7918f24d
NC		 910
911 PERL_ARGS_ASSERT_SCALARBOOLEAN;
912
d008e5eb 913 if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) {
d008e5eb 914 if (ckWARN(WARN_SYNTAX)) {
6867be6d 915 const line_t oldline = CopLINE(PL_curcop);
a0d0e21e 916
53a7735b
DM		 917 if (PL_parser && PL_parser->copline != NOLINE)
918 CopLINE_set(PL_curcop, PL_parser->copline);
9014280d 919 Perl_warner(aTHX_ packWARN(WARN_SYNTAX), "Found = in conditional, should be ==");
57843af0 920 CopLINE_set(PL_curcop, oldline);
d008e5eb 921 }
a0d0e21e 922 }
11343788 923 return scalar(o);
8990e307
LW		 924}
925
926OP *
864dbfa3 927Perl_scalar(pTHX_ OP *o)
79072805 928{
27da23d5 929 dVAR;
79072805
LW		 930 OP *kid;
931
a0d0e21e 932 /* assumes no premature commitment */
13765c85
DM		 933 if (!o || (PL_parser && PL_parser->error_count)
934 || (o->op_flags & OPf_WANT)
5dc0d613 935 || o->op_type == OP_RETURN)
7e363e51 936 {
11343788 937 return o;
7e363e51 938 }
79072805 939
5dc0d613 940 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_SCALAR;
79072805 941
11343788 942 switch (o->op_type) {
79072805 943 case OP_REPEAT:
11343788 944 scalar(cBINOPo->op_first);
8990e307 945 break;
79072805
LW		 946 case OP_OR:
947 case OP_AND:
948 case OP_COND_EXPR:
11343788 949 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
8990e307 950 scalar(kid);
79072805 951 break;
a0d0e21e 952 /* FALL THROUGH */
a6d8037e 953 case OP_SPLIT:
79072805 954 case OP_MATCH:
8782bef2 955 case OP_QR:
79072805
LW		 956 case OP_SUBST:
957 case OP_NULL:
8990e307 958 default:
11343788
MB		 959 if (o->op_flags & OPf_KIDS) {
960 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
8990e307
LW		 961 scalar(kid);
962 }
79072805
LW		 963 break;
964 case OP_LEAVE:
965 case OP_LEAVETRY:
5dc0d613 966 kid = cLISTOPo->op_first;
54310121 967 scalar(kid);
25b991bf
VP		 968 kid = kid->op_sibling;
969 do_kids:
970 while (kid) {
971 OP *sib = kid->op_sibling;
972 if (sib && kid->op_type != OP_LEAVEWHEN) {
973 if (sib->op_type == OP_BREAK && sib->op_flags & OPf_SPECIAL) {
974 scalar(kid);
975 scalarvoid(sib);
976 break;
977 } else
978 scalarvoid(kid);
979 } else
54310121 980 scalar(kid);
25b991bf 981 kid = sib;
54310121 982 }
11206fdd 983 PL_curcop = &PL_compiling;
54310121 984 break;
748a9306 985 case OP_SCOPE:
79072805 986 case OP_LINESEQ:
8990e307 987 case OP_LIST:
25b991bf
VP		 988 kid = cLISTOPo->op_first;
989 goto do_kids;
a801c63c 990 case OP_SORT:
a2a5de95 991 Perl_ck_warner(aTHX_ packWARN(WARN_VOID), "Useless use of sort in scalar context");
553e7bb0 992 break;
79072805 993 }
11343788 994 return o;
79072805
LW		 995}
996
997OP *
864dbfa3 998Perl_scalarvoid(pTHX_ OP *o)
79072805 999{
27da23d5 1000 dVAR;
79072805 1001 OP *kid;
c445ea15 1002 const char* useless = NULL;
8990e307 1003 SV* sv;
2ebea0a1
GS		 1004 U8 want;
1005
7918f24d
NC		 1006 PERL_ARGS_ASSERT_SCALARVOID;
1007
eb8433b7
NC		 1008 /* trailing mad null ops don't count as "there" for void processing */
1009 if (PL_madskills &&
1010 o->op_type != OP_NULL &&
1011 o->op_sibling &&
1012 o->op_sibling->op_type == OP_NULL)
1013 {
1014 OP *sib;
1015 for (sib = o->op_sibling;
1016 sib && sib->op_type == OP_NULL;
1017 sib = sib->op_sibling) ;
1018
1019 if (!sib)
1020 return o;
1021 }
1022
acb36ea4 1023 if (o->op_type == OP_NEXTSTATE
acb36ea4
GS		 1024 || o->op_type == OP_DBSTATE
1025 || (o->op_type == OP_NULL && (o->op_targ == OP_NEXTSTATE
acb36ea4 1026 || o->op_targ == OP_DBSTATE)))
2ebea0a1 1027 PL_curcop = (COP*)o; /* for warning below */
79072805 1028
54310121 1029 /* assumes no premature commitment */
2ebea0a1 1030 want = o->op_flags & OPf_WANT;
13765c85
DM		 1031 if ((want && want != OPf_WANT_SCALAR)
1032 || (PL_parser && PL_parser->error_count)
25b991bf 1033 || o->op_type == OP_RETURN || o->op_type == OP_REQUIRE || o->op_type == OP_LEAVEWHEN)
7e363e51 1034 {
11343788 1035 return o;
7e363e51 1036 }
79072805 1037
b162f9ea 1038 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS		 1039 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1040 {
b162f9ea 1041 return scalar(o); /* As if inside SASSIGN */
7e363e51 1042 }
1c846c1f 1043
5dc0d613 1044 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
79072805 1045
11343788 1046 switch (o->op_type) {
79072805 1047 default:
22c35a8c 1048 if (!(PL_opargs[o->op_type] & OA_FOLDCONST))
8990e307 1049 break;
36477c24 1050 /* FALL THROUGH */
1051 case OP_REPEAT:
11343788 1052 if (o->op_flags & OPf_STACKED)
8990e307 1053 break;
5d82c453
GA		 1054 goto func_ops;
1055 case OP_SUBSTR:
1056 if (o->op_private == 4)
1057 break;
8990e307
LW		 1058 /* FALL THROUGH */
1059 case OP_GVSV:
1060 case OP_WANTARRAY:
1061 case OP_GV:
74295f0b 1062 case OP_SMARTMATCH:
8990e307
LW		 1063 case OP_PADSV:
1064 case OP_PADAV:
1065 case OP_PADHV:
1066 case OP_PADANY:
1067 case OP_AV2ARYLEN:
8990e307 1068 case OP_REF:
a0d0e21e
LW		 1069 case OP_REFGEN:
1070 case OP_SREFGEN:
8990e307
LW		 1071 case OP_DEFINED:
1072 case OP_HEX:
1073 case OP_OCT:
1074 case OP_LENGTH:
8990e307
LW		 1075 case OP_VEC:
1076 case OP_INDEX:
1077 case OP_RINDEX:
1078 case OP_SPRINTF:
1079 case OP_AELEM:
1080 case OP_AELEMFAST:
1081 case OP_ASLICE:
8990e307
LW		 1082 case OP_HELEM:
1083 case OP_HSLICE:
1084 case OP_UNPACK:
1085 case OP_PACK:
8990e307
LW		 1086 case OP_JOIN:
1087 case OP_LSLICE:
1088 case OP_ANONLIST:
1089 case OP_ANONHASH:
1090 case OP_SORT:
1091 case OP_REVERSE:
1092 case OP_RANGE:
1093 case OP_FLIP:
1094 case OP_FLOP:
1095 case OP_CALLER:
1096 case OP_FILENO:
1097 case OP_EOF:
1098 case OP_TELL:
1099 case OP_GETSOCKNAME:
1100 case OP_GETPEERNAME:
1101 case OP_READLINK:
1102 case OP_TELLDIR:
1103 case OP_GETPPID:
1104 case OP_GETPGRP:
1105 case OP_GETPRIORITY:
1106 case OP_TIME:
1107 case OP_TMS:
1108 case OP_LOCALTIME:
1109 case OP_GMTIME:
1110 case OP_GHBYNAME:
1111 case OP_GHBYADDR:
1112 case OP_GHOSTENT:
1113 case OP_GNBYNAME:
1114 case OP_GNBYADDR:
1115 case OP_GNETENT:
1116 case OP_GPBYNAME:
1117 case OP_GPBYNUMBER:
1118 case OP_GPROTOENT:
1119 case OP_GSBYNAME:
1120 case OP_GSBYPORT:
1121 case OP_GSERVENT:
1122 case OP_GPWNAM:
1123 case OP_GPWUID:
1124 case OP_GGRNAM:
1125 case OP_GGRGID:
1126 case OP_GETLOGIN:
78e1b766 1127 case OP_PROTOTYPE:
5d82c453 1128 func_ops:
64aac5a9 1129 if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)))
74295f0b 1130 /* Otherwise it's "Useless use of grep iterator" */
f5df4782 1131 useless = OP_DESC(o);
75068674
RGS		 1132 break;
1133
1134 case OP_SPLIT:
1135 kid = cLISTOPo->op_first;
1136 if (kid && kid->op_type == OP_PUSHRE
1137#ifdef USE_ITHREADS
1138 && !((PMOP*)kid)->op_pmreplrootu.op_pmtargetoff)
1139#else
1140 && !((PMOP*)kid)->op_pmreplrootu.op_pmtargetgv)
1141#endif
1142 useless = OP_DESC(o);
8990e307
LW		 1143 break;
1144
9f82cd5f
YST		 1145 case OP_NOT:
1146 kid = cUNOPo->op_first;
1147 if (kid->op_type != OP_MATCH && kid->op_type != OP_SUBST &&
bb16bae8 1148 kid->op_type != OP_TRANS && kid->op_type != OP_TRANSR) {
9f82cd5f
YST		 1149 goto func_ops;
1150 }
1151 useless = "negative pattern binding (!~)";
1152 break;
1153
4f4d7508
DC		 1154 case OP_SUBST:
1155 if (cPMOPo->op_pmflags & PMf_NONDESTRUCT)
8db9069c 1156 useless = "non-destructive substitution (s///r)";
4f4d7508
DC		 1157 break;
1158
bb16bae8
FC		 1159 case OP_TRANSR:
1160 useless = "non-destructive transliteration (tr///r)";
1161 break;
1162
8990e307
LW		 1163 case OP_RV2GV:
1164 case OP_RV2SV:
1165 case OP_RV2AV:
1166 case OP_RV2HV:
192587c2 1167 if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)) &&
11343788 1168 (!o->op_sibling || o->op_sibling->op_type != OP_READLINE))
8990e307
LW		 1169 useless = "a variable";
1170 break;
79072805
LW		 1171
1172 case OP_CONST:
7766f137 1173 sv = cSVOPo_sv;
7a52d87a
GS		 1174 if (cSVOPo->op_private & OPpCONST_STRICT)
1175 no_bareword_allowed(o);
1176 else {
d008e5eb 1177 if (ckWARN(WARN_VOID)) {
fa01e093
RGS		 1178 if (SvOK(sv)) {
1179 SV* msv = sv_2mortal(Perl_newSVpvf(aTHX_
1180 "a constant (%"SVf")", sv));
1181 useless = SvPV_nolen(msv);
1182 }
1183 else
1184 useless = "a constant (undef)";
2e0ae2d3 1185 if (o->op_private & OPpCONST_ARYBASE)
d4c19fe8 1186 useless = NULL;
e7fec78e 1187 /* don't warn on optimised away booleans, eg
b5a930ec 1188 * use constant Foo, 5; Foo || print; */
e7fec78e 1189 if (cSVOPo->op_private & OPpCONST_SHORTCIRCUIT)
d4c19fe8 1190 useless = NULL;
960b4253
MG		 1191 /* the constants 0 and 1 are permitted as they are
1192 conventionally used as dummies in constructs like
1193 1 while some_condition_with_side_effects; */
e7fec78e 1194 else if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0))
d4c19fe8 1195 useless = NULL;
d008e5eb 1196 else if (SvPOK(sv)) {
a52fe3ac
A		 1197 /* perl4's way of mixing documentation and code
1198 (before the invention of POD) was based on a
1199 trick to mix nroff and perl code. The trick was
1200 built upon these three nroff macros being used in
1201 void context. The pink camel has the details in
1202 the script wrapman near page 319. */
6136c704
AL		 1203 const char * const maybe_macro = SvPVX_const(sv);
1204 if (strnEQ(maybe_macro, "di", 2) ||
1205 strnEQ(maybe_macro, "ds", 2) ||
1206 strnEQ(maybe_macro, "ig", 2))
d4c19fe8 1207 useless = NULL;
d008e5eb 1208 }
8990e307
LW		 1209 }
1210 }
93c66552 1211 op_null(o); /* don't execute or even remember it */
79072805
LW		 1212 break;
1213
1214 case OP_POSTINC:
11343788 1215 o->op_type = OP_PREINC; /* pre-increment is faster */
22c35a8c 1216 o->op_ppaddr = PL_ppaddr[OP_PREINC];
79072805
LW		 1217 break;
1218
1219 case OP_POSTDEC:
11343788 1220 o->op_type = OP_PREDEC; /* pre-decrement is faster */
22c35a8c 1221 o->op_ppaddr = PL_ppaddr[OP_PREDEC];
79072805
LW		 1222 break;
1223
679d6c4e
HS		 1224 case OP_I_POSTINC:
1225 o->op_type = OP_I_PREINC; /* pre-increment is faster */
1226 o->op_ppaddr = PL_ppaddr[OP_I_PREINC];
1227 break;
1228
1229 case OP_I_POSTDEC:
1230 o->op_type = OP_I_PREDEC; /* pre-decrement is faster */
1231 o->op_ppaddr = PL_ppaddr[OP_I_PREDEC];
1232 break;
1233
79072805
LW		 1234 case OP_OR:
1235 case OP_AND:
edbe35ea
VP		 1236 kid = cLOGOPo->op_first;
1237 if (kid->op_type == OP_NOT
1238 && (kid->op_flags & OPf_KIDS)
1239 && !PL_madskills) {
1240 if (o->op_type == OP_AND) {
1241 o->op_type = OP_OR;
1242 o->op_ppaddr = PL_ppaddr[OP_OR];
1243 } else {
1244 o->op_type = OP_AND;
1245 o->op_ppaddr = PL_ppaddr[OP_AND];
1246 }
1247 op_null(kid);
1248 }
1249
c963b151 1250 case OP_DOR:
79072805 1251 case OP_COND_EXPR:
0d863452
RH		 1252 case OP_ENTERGIVEN:
1253 case OP_ENTERWHEN:
11343788 1254 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
79072805
LW		 1255 scalarvoid(kid);
1256 break;
5aabfad6 1257
a0d0e21e 1258 case OP_NULL:
11343788 1259 if (o->op_flags & OPf_STACKED)
a0d0e21e 1260 break;
5aabfad6 1261 /* FALL THROUGH */
2ebea0a1
GS		 1262 case OP_NEXTSTATE:
1263 case OP_DBSTATE:
79072805
LW		 1264 case OP_ENTERTRY:
1265 case OP_ENTER:
11343788 1266 if (!(o->op_flags & OPf_KIDS))
79072805 1267 break;
54310121 1268 /* FALL THROUGH */
463ee0b2 1269 case OP_SCOPE:
79072805
LW		 1270 case OP_LEAVE:
1271 case OP_LEAVETRY:
a0d0e21e 1272 case OP_LEAVELOOP:
79072805 1273 case OP_LINESEQ:
79072805 1274 case OP_LIST:
0d863452
RH		 1275 case OP_LEAVEGIVEN:
1276 case OP_LEAVEWHEN:
11343788 1277 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW		 1278 scalarvoid(kid);
1279 break;
c90c0ff4 1280 case OP_ENTEREVAL:
5196be3e 1281 scalarkids(o);
c90c0ff4 1282 break;
d6483035 1283 case OP_SCALAR:
5196be3e 1284 return scalar(o);
79072805 1285 }
a2a5de95
NC		 1286 if (useless)
1287 Perl_ck_warner(aTHX_ packWARN(WARN_VOID), "Useless use of %s in void context", useless);
11343788 1288 return o;
79072805
LW		 1289}
1290
1f676739 1291static OP *
412da003 1292S_listkids(pTHX_ OP *o)
79072805 1293{
11343788 1294 if (o && o->op_flags & OPf_KIDS) {
6867be6d 1295 OP *kid;
11343788 1296 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW		 1297 list(kid);
1298 }
11343788 1299 return o;
79072805
LW		 1300}
1301
1302OP *
864dbfa3 1303Perl_list(pTHX_ OP *o)
79072805 1304{
27da23d5 1305 dVAR;
79072805
LW		 1306 OP *kid;
1307
a0d0e21e 1308 /* assumes no premature commitment */
13765c85
DM		 1309 if (!o || (o->op_flags & OPf_WANT)
1310 || (PL_parser && PL_parser->error_count)
5dc0d613 1311 || o->op_type == OP_RETURN)
7e363e51 1312 {
11343788 1313 return o;
7e363e51 1314 }
79072805 1315
b162f9ea 1316 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS		 1317 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1318 {
b162f9ea 1319 return o; /* As if inside SASSIGN */
7e363e51 1320 }
1c846c1f 1321
5dc0d613 1322 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_LIST;
79072805 1323
11343788 1324 switch (o->op_type) {
79072805
LW		 1325 case OP_FLOP:
1326 case OP_REPEAT:
11343788 1327 list(cBINOPo->op_first);
79072805
LW		 1328 break;
1329 case OP_OR:
1330 case OP_AND:
1331 case OP_COND_EXPR:
11343788 1332 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
79072805
LW		 1333 list(kid);
1334 break;
1335 default:
1336 case OP_MATCH:
8782bef2 1337 case OP_QR:
79072805
LW		 1338 case OP_SUBST:
1339 case OP_NULL:
11343788 1340 if (!(o->op_flags & OPf_KIDS))
79072805 1341 break;
11343788
MB		 1342 if (!o->op_next && cUNOPo->op_first->op_type == OP_FLOP) {
1343 list(cBINOPo->op_first);
1344 return gen_constant_list(o);
79072805
LW		 1345 }
1346 case OP_LIST:
11343788 1347 listkids(o);
79072805
LW		 1348 break;
1349 case OP_LEAVE:
1350 case OP_LEAVETRY:
5dc0d613 1351 kid = cLISTOPo->op_first;
54310121 1352 list(kid);
25b991bf
VP		 1353 kid = kid->op_sibling;
1354 do_kids:
1355 while (kid) {
1356 OP *sib = kid->op_sibling;
1357 if (sib && kid->op_type != OP_LEAVEWHEN) {
1358 if (sib->op_type == OP_BREAK && sib->op_flags & OPf_SPECIAL) {
1359 list(kid);
1360 scalarvoid(sib);
1361 break;
1362 } else
1363 scalarvoid(kid);
1364 } else
54310121 1365 list(kid);
25b991bf 1366 kid = sib;
54310121 1367 }
11206fdd 1368 PL_curcop = &PL_compiling;
54310121 1369 break;
748a9306 1370 case OP_SCOPE:
79072805 1371 case OP_LINESEQ:
25b991bf
VP		 1372 kid = cLISTOPo->op_first;
1373 goto do_kids;
79072805 1374 }
11343788 1375 return o;
79072805
LW		 1376}
1377
1f676739 1378static OP *
2dd5337b 1379S_scalarseq(pTHX_ OP *o)
79072805 1380{
97aff369 1381 dVAR;
11343788 1382 if (o) {
1496a290
AL		 1383 const OPCODE type = o->op_type;
1384
1385 if (type == OP_LINESEQ || type == OP_SCOPE ||
1386 type == OP_LEAVE || type == OP_LEAVETRY)
463ee0b2 1387 {
6867be6d 1388 OP *kid;
11343788 1389 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
ed6116ce 1390 if (kid->op_sibling) {
463ee0b2 1391 scalarvoid(kid);
ed6116ce 1392 }
463ee0b2 1393 }
3280af22 1394 PL_curcop = &PL_compiling;
79072805 1395 }
11343788 1396 o->op_flags &= ~OPf_PARENS;
3280af22 1397 if (PL_hints & HINT_BLOCK_SCOPE)
11343788 1398 o->op_flags |= OPf_PARENS;
79072805 1399 }
8990e307 1400 else
11343788
MB		 1401 o = newOP(OP_STUB, 0);
1402 return o;
79072805
LW		 1403}
1404
76e3520e 1405STATIC OP *
cea2e8a9 1406S_modkids(pTHX_ OP *o, I32 type)
79072805 1407{
11343788 1408 if (o && o->op_flags & OPf_KIDS) {
6867be6d 1409 OP *kid;
11343788 1410 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
3ad73efd 1411 op_lvalue(kid, type);
79072805 1412 }
11343788 1413 return o;
79072805
LW		 1414}
1415
3ad73efd
Z		 1416/*
1417=for apidoc Amx|OP *|op_lvalue|OP *o|I32 type
1418
1419Propagate lvalue ("modifiable") context to an op and its children.
1420I<type> represents the context type, roughly based on the type of op that
1421would do the modifying, although C<local()> is represented by OP_NULL,
1422because it has no op type of its own (it is signalled by a flag on
001c3c51
FC		 1423the lvalue op).
1424
1425This function detects things that can't be modified, such as C<$x+1>, and
1426generates errors for them. For example, C<$x+1 = 2> would cause it to be
1427called with an op of type OP_ADD and a C<type> argument of OP_SASSIGN.
1428
1429It also flags things that need to behave specially in an lvalue context,
1430such as C<$$x = 5> which might have to vivify a reference in C<$x>.
3ad73efd
Z		 1431
1432=cut
1433*/
ddeae0f1 1434
79072805 1435OP *
3ad73efd 1436Perl_op_lvalue(pTHX_ OP *o, I32 type)
79072805 1437{
27da23d5 1438 dVAR;
79072805 1439 OP *kid;
ddeae0f1
DM		 1440 /* -1 = error on localize, 0 = ignore localize, 1 = ok to localize */
1441 int localize = -1;
79072805 1442
13765c85 1443 if (!o || (PL_parser && PL_parser->error_count))
11343788 1444 return o;
79072805 1445
b162f9ea 1446 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS		 1447 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1448 {
b162f9ea 1449 return o;
7e363e51 1450 }
1c846c1f 1451
11343788 1452 switch (o->op_type) {
68dc0745 1453 case OP_UNDEF:
ddeae0f1 1454 localize = 0;
3280af22 1455 PL_modcount++;
5dc0d613 1456 return o;
a0d0e21e 1457 case OP_CONST:
2e0ae2d3 1458 if (!(o->op_private & OPpCONST_ARYBASE))
a0d0e21e 1459 goto nomod;
54dc0f91 1460 localize = 0;
3280af22 1461 if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
fc15ae8f
NC		 1462 CopARYBASE_set(&PL_compiling,
1463 (I32)SvIV(cSVOPx(PL_eval_start)->op_sv));
3280af22 1464 PL_eval_start = 0;
a0d0e21e
LW		 1465 }
1466 else if (!type) {
fc15ae8f
NC		 1467 SAVECOPARYBASE(&PL_compiling);
1468 CopARYBASE_set(&PL_compiling, 0);
a0d0e21e
LW		 1469 }
1470 else if (type == OP_REFGEN)
1471 goto nomod;
1472 else
cea2e8a9 1473 Perl_croak(aTHX_ "That use of $[ is unsupported");
a0d0e21e 1474 break;
5f05dabc 1475 case OP_STUB:
58bde88d 1476 if ((o->op_flags & OPf_PARENS) || PL_madskills)
5f05dabc 1477 break;
1478 goto nomod;
a0d0e21e
LW		 1479 case OP_ENTERSUB:
1480 if ((type == OP_UNDEF || type == OP_REFGEN) &&
11343788
MB		 1481 !(o->op_flags & OPf_STACKED)) {
1482 o->op_type = OP_RV2CV; /* entersub => rv2cv */
e26df76a
NC		 1483 /* The default is to set op_private to the number of children,
1484 which for a UNOP such as RV2CV is always 1. And w're using
1485 the bit for a flag in RV2CV, so we need it clear. */
1486 o->op_private &= ~1;
22c35a8c 1487 o->op_ppaddr = PL_ppaddr[OP_RV2CV];
11343788 1488 assert(cUNOPo->op_first->op_type == OP_NULL);
93c66552 1489 op_null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
79072805
LW		 1490 break;
1491 }
95f0a2f1
SB		 1492 else if (o->op_private & OPpENTERSUB_NOMOD)
1493 return o;
cd06dffe
GS		 1494 else { /* lvalue subroutine call */
1495 o->op_private |= OPpLVAL_INTRO;
e6438c1a 1496 PL_modcount = RETURN_UNLIMITED_NUMBER;
4978d6d9 1497 if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN) {
cd06dffe
GS		 1498 /* Backward compatibility mode: */
1499 o->op_private |= OPpENTERSUB_INARGS;
1500 break;
1501 }
1502 else { /* Compile-time error message: */
1503 OP *kid = cUNOPo->op_first;
1504 CV *cv;
1505 OP *okid;
1506
3ea285d1
AL		 1507 if (kid->op_type != OP_PUSHMARK) {
1508 if (kid->op_type != OP_NULL || kid->op_targ != OP_LIST)
1509 Perl_croak(aTHX_
1510 "panic: unexpected lvalue entersub "
1511 "args: type/targ %ld:%"UVuf,
1512 (long)kid->op_type, (UV)kid->op_targ);
1513 kid = kLISTOP->op_first;
1514 }
cd06dffe
GS		 1515 while (kid->op_sibling)
1516 kid = kid->op_sibling;
1517 if (!(kid->op_type == OP_NULL && kid->op_targ == OP_RV2CV)) {
1518 /* Indirect call */
1519 if (kid->op_type == OP_METHOD_NAMED
1520 || kid->op_type == OP_METHOD)
1521 {
87d7fd28 1522 UNOP *newop;
b2ffa427 1523
87d7fd28 1524 NewOp(1101, newop, 1, UNOP);
349fd7b7
GS		 1525 newop->op_type = OP_RV2CV;
1526 newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
5f66b61c 1527 newop->op_first = NULL;
87d7fd28
GS		 1528 newop->op_next = (OP*)newop;
1529 kid->op_sibling = (OP*)newop;
349fd7b7 1530 newop->op_private |= OPpLVAL_INTRO;
e26df76a 1531 newop->op_private &= ~1;
cd06dffe
GS		 1532 break;
1533 }
b2ffa427 1534
cd06dffe
GS		 1535 if (kid->op_type != OP_RV2CV)
1536 Perl_croak(aTHX_
1537 "panic: unexpected lvalue entersub "
55140b79 1538 "entry via type/targ %ld:%"UVuf,
3d811634 1539 (long)kid->op_type, (UV)kid->op_targ);
cd06dffe
GS		 1540 kid->op_private |= OPpLVAL_INTRO;
1541 break; /* Postpone until runtime */
1542 }
b2ffa427
NIS		 1543
1544 okid = kid;
cd06dffe
GS		 1545 kid = kUNOP->op_first;
1546 if (kid->op_type == OP_NULL && kid->op_targ == OP_RV2SV)
1547 kid = kUNOP->op_first;
b2ffa427 1548 if (kid->op_type == OP_NULL)
cd06dffe
GS		 1549 Perl_croak(aTHX_
1550 "Unexpected constant lvalue entersub "
55140b79 1551 "entry via type/targ %ld:%"UVuf,
3d811634 1552 (long)kid->op_type, (UV)kid->op_targ);
cd06dffe
GS		 1553 if (kid->op_type != OP_GV) {
1554 /* Restore RV2CV to check lvalueness */
1555 restore_2cv:
1556 if (kid->op_next && kid->op_next != kid) { /* Happens? */
1557 okid->op_next = kid->op_next;
1558 kid->op_next = okid;
1559 }
1560 else
5f66b61c 1561 okid->op_next = NULL;
cd06dffe
GS		 1562 okid->op_type = OP_RV2CV;
1563 okid->op_targ = 0;
1564 okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
1565 okid->op_private |= OPpLVAL_INTRO;
e26df76a 1566 okid->op_private &= ~1;
cd06dffe
GS		 1567 break;
1568 }
b2ffa427 1569
638eceb6 1570 cv = GvCV(kGVOP_gv);
1c846c1f 1571 if (!cv)
cd06dffe
GS		 1572 goto restore_2cv;
1573 if (CvLVALUE(cv))
1574 break;
1575 }
1576 }
79072805
LW		 1577 /* FALL THROUGH */
1578 default:
a0d0e21e 1579 nomod:
6fbb66d6
NC		 1580 /* grep, foreach, subcalls, refgen */
1581 if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN)
a0d0e21e 1582 break;
cea2e8a9 1583 yyerror(Perl_form(aTHX_ "Can't modify %s in %s",
638bc118 1584 (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)
cd06dffe
GS		 1585 ? "do block"
1586 : (o->op_type == OP_ENTERSUB
1587 ? "non-lvalue subroutine call"
53e06cf0 1588 : OP_DESC(o))),
22c35a8c 1589 type ? PL_op_desc[type] : "local"));
11343788 1590 return o;
79072805 1591
a0d0e21e
LW		 1592 case OP_PREINC:
1593 case OP_PREDEC:
1594 case OP_POW:
1595 case OP_MULTIPLY:
1596 case OP_DIVIDE:
1597 case OP_MODULO:
1598 case OP_REPEAT:
1599 case OP_ADD:
1600 case OP_SUBTRACT:
1601 case OP_CONCAT:
1602 case OP_LEFT_SHIFT:
1603 case OP_RIGHT_SHIFT:
1604 case OP_BIT_AND:
1605 case OP_BIT_XOR:
1606 case OP_BIT_OR:
1607 case OP_I_MULTIPLY:
1608 case OP_I_DIVIDE:
1609 case OP_I_MODULO:
1610 case OP_I_ADD:
1611 case OP_I_SUBTRACT:
11343788 1612 if (!(o->op_flags & OPf_STACKED))
a0d0e21e 1613 goto nomod;
3280af22 1614 PL_modcount++;
a0d0e21e 1615 break;
b2ffa427 1616
79072805 1617 case OP_COND_EXPR:
ddeae0f1 1618 localize = 1;
11343788 1619 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
3ad73efd 1620 op_lvalue(kid, type);
79072805
LW		 1621 break;
1622
1623 case OP_RV2AV:
1624 case OP_RV2HV:
11343788 1625 if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
e6438c1a 1626 PL_modcount = RETURN_UNLIMITED_NUMBER;
11343788 1627 return o; /* Treat \(@foo) like ordinary list. */
748a9306
LW		 1628 }
1629 /* FALL THROUGH */
79072805 1630 case OP_RV2GV:
5dc0d613 1631 if (scalar_mod_type(o, type))
3fe9a6f1 1632 goto nomod;
11343788 1633 ref(cUNOPo->op_first, o->op_type);
79072805 1634 /* FALL THROUGH */
79072805
LW		 1635 case OP_ASLICE:
1636 case OP_HSLICE:
78f9721b
SM		 1637 if (type == OP_LEAVESUBLV)
1638 o->op_private |= OPpMAYBE_LVSUB;
ddeae0f1 1639 localize = 1;
78f9721b
SM		 1640 /* FALL THROUGH */
1641 case OP_AASSIGN:
93a17b20
LW		 1642 case OP_NEXTSTATE:
1643 case OP_DBSTATE:
e6438c1a 1644 PL_modcount = RETURN_UNLIMITED_NUMBER;
79072805 1645 break;
28c5b5bc
RGS		 1646 case OP_AV2ARYLEN:
1647 PL_hints |= HINT_BLOCK_SCOPE;
1648 if (type == OP_LEAVESUBLV)
1649 o->op_private |= OPpMAYBE_LVSUB;
1650 PL_modcount++;
1651 break;
463ee0b2 1652 case OP_RV2SV:
aeea060c 1653 ref(cUNOPo->op_first, o->op_type);
ddeae0f1 1654 localize = 1;
463ee0b2 1655 /* FALL THROUGH */
79072805 1656 case OP_GV:
3280af22 1657 PL_hints |= HINT_BLOCK_SCOPE;
463ee0b2 1658 case OP_SASSIGN:
bf4b1e52
GS		 1659 case OP_ANDASSIGN:
1660 case OP_ORASSIGN:
c963b151 1661 case OP_DORASSIGN:
ddeae0f1
DM		 1662 PL_modcount++;
1663 break;
1664
8990e307 1665 case OP_AELEMFAST:
6a077020 1666 localize = -1;
3280af22 1667 PL_modcount++;
8990e307
LW		 1668 break;
1669
748a9306
LW		 1670 case OP_PADAV:
1671 case OP_PADHV:
e6438c1a 1672 PL_modcount = RETURN_UNLIMITED_NUMBER;
5196be3e
MB		 1673 if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
1674 return o; /* Treat \(@foo) like ordinary list. */
1675 if (scalar_mod_type(o, type))
3fe9a6f1 1676 goto nomod;
78f9721b
SM		 1677 if (type == OP_LEAVESUBLV)
1678 o->op_private |= OPpMAYBE_LVSUB;
748a9306
LW		 1679 /* FALL THROUGH */
1680 case OP_PADSV:
3280af22 1681 PL_modcount++;
ddeae0f1 1682 if (!type) /* local() */
cea2e8a9 1683 Perl_croak(aTHX_ "Can't localize lexical variable %s",
dd2155a4 1684 PAD_COMPNAME_PV(o->op_targ));
463ee0b2
LW		 1685 break;
1686
748a9306 1687 case OP_PUSHMARK:
ddeae0f1 1688 localize = 0;
748a9306 1689 break;
b2ffa427 1690
69969c6f
SB		 1691 case OP_KEYS:
1692 if (type != OP_SASSIGN)
1693 goto nomod;
5d82c453
GA		 1694 goto lvalue_func;
1695 case OP_SUBSTR:
1696 if (o->op_private == 4) /* don't allow 4 arg substr as lvalue */
1697 goto nomod;
5f05dabc 1698 /* FALL THROUGH */
a0d0e21e 1699 case OP_POS:
463ee0b2 1700 case OP_VEC:
78f9721b
SM		 1701 if (type == OP_LEAVESUBLV)
1702 o->op_private |= OPpMAYBE_LVSUB;
5d82c453 1703 lvalue_func:
11343788
MB		 1704 pad_free(o->op_targ);
1705 o->op_targ = pad_alloc(o->op_type, SVs_PADMY);
5dc0d613 1706 assert(SvTYPE(PAD_SV(o->op_targ)) == SVt_NULL);
11343788 1707 if (o->op_flags & OPf_KIDS)
3ad73efd 1708 op_lvalue(cBINOPo->op_first->op_sibling, type);
463ee0b2 1709 break;
a0d0e21e 1710
463ee0b2
LW		 1711 case OP_AELEM:
1712 case OP_HELEM:
11343788 1713 ref(cBINOPo->op_first, o->op_type);
68dc0745 1714 if (type == OP_ENTERSUB &&
5dc0d613
MB		 1715 !(o->op_private & (OPpLVAL_INTRO | OPpDEREF)))
1716 o->op_private |= OPpLVAL_DEFER;
78f9721b
SM		 1717 if (type == OP_LEAVESUBLV)
1718 o->op_private |= OPpMAYBE_LVSUB;
ddeae0f1 1719 localize = 1;
3280af22 1720 PL_modcount++;
463ee0b2
LW		 1721 break;
1722
1723 case OP_SCOPE:
1724 case OP_LEAVE:
1725 case OP_ENTER:
78f9721b 1726 case OP_LINESEQ:
ddeae0f1 1727 localize = 0;
11343788 1728 if (o->op_flags & OPf_KIDS)
3ad73efd 1729 op_lvalue(cLISTOPo->op_last, type);
a0d0e21e
LW		 1730 break;
1731
1732 case OP_NULL:
ddeae0f1 1733 localize = 0;
638bc118
GS		 1734 if (o->op_flags & OPf_SPECIAL) /* do BLOCK */
1735 goto nomod;
1736 else if (!(o->op_flags & OPf_KIDS))
463ee0b2 1737 break;
11343788 1738 if (o->op_targ != OP_LIST) {
3ad73efd 1739 op_lvalue(cBINOPo->op_first, type);
a0d0e21e
LW		 1740 break;
1741 }
1742 /* FALL THROUGH */
463ee0b2 1743 case OP_LIST:
ddeae0f1 1744 localize = 0;
11343788 1745 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
3ad73efd 1746 op_lvalue(kid, type);
463ee0b2 1747 break;
78f9721b
SM		 1748
1749 case OP_RETURN:
1750 if (type != OP_LEAVESUBLV)
1751 goto nomod;
3ad73efd 1752 break; /* op_lvalue()ing was handled by ck_return() */
463ee0b2 1753 }
58d95175 1754
8be1be90
AMS		 1755 /* [20011101.069] File test operators interpret OPf_REF to mean that
1756 their argument is a filehandle; thus \stat(".") should not set
1757 it. AMS 20011102 */
1758 if (type == OP_REFGEN &&
ef69c8fc 1759 PL_check[o->op_type] == Perl_ck_ftst)
8be1be90
AMS		 1760 return o;
1761
1762 if (type != OP_LEAVESUBLV)
1763 o->op_flags |= OPf_MOD;
1764
1765 if (type == OP_AASSIGN || type == OP_SASSIGN)
1766 o->op_flags |= OPf_SPECIAL|OPf_REF;
ddeae0f1
DM		 1767 else if (!type) { /* local() */
1768 switch (localize) {
1769 case 1:
1770 o->op_private |= OPpLVAL_INTRO;
1771 o->op_flags &= ~OPf_SPECIAL;
1772 PL_hints |= HINT_BLOCK_SCOPE;
1773 break;
1774 case 0:
1775 break;
1776 case -1:
a2a5de95
NC		 1777 Perl_ck_warner(aTHX_ packWARN(WARN_SYNTAX),
1778 "Useless localization of %s", OP_DESC(o));
ddeae0f1 1779 }
463ee0b2 1780 }
8be1be90
AMS		 1781 else if (type != OP_GREPSTART && type != OP_ENTERSUB
1782 && type != OP_LEAVESUBLV)
1783 o->op_flags |= OPf_REF;
11343788 1784 return o;
463ee0b2
LW		 1785}
1786
8b47453d
FC		 1787/* Do not use this. It will be removed after 5.14. */
1788OP *
1789Perl_mod(pTHX_ OP *o, I32 type)
1790{
1791 return op_lvalue(o,type);
1792}
1793
1794
864dbfa3 1795STATIC bool
5f66b61c 1796S_scalar_mod_type(const OP *o, I32 type)
3fe9a6f1 1797{
7918f24d
NC		 1798 PERL_ARGS_ASSERT_SCALAR_MOD_TYPE;
1799
3fe9a6f1 1800 switch (type) {
1801 case OP_SASSIGN:
5196be3e 1802 if (o->op_type == OP_RV2GV)
3fe9a6f1 1803 return FALSE;
1804 /* FALL THROUGH */
1805 case OP_PREINC:
1806 case OP_PREDEC:
1807 case OP_POSTINC:
1808 case OP_POSTDEC:
1809 case OP_I_PREINC:
1810 case OP_I_PREDEC:
1811 case OP_I_POSTINC:
1812 case OP_I_POSTDEC:
1813 case OP_POW:
1814 case OP_MULTIPLY:
1815 case OP_DIVIDE:
1816 case OP_MODULO:
1817 case OP_REPEAT:
1818 case OP_ADD:
1819 case OP_SUBTRACT:
1820 case OP_I_MULTIPLY:
1821 case OP_I_DIVIDE:
1822 case OP_I_MODULO:
1823 case OP_I_ADD:
1824 case OP_I_SUBTRACT:
1825 case OP_LEFT_SHIFT:
1826 case OP_RIGHT_SHIFT:
1827 case OP_BIT_AND:
1828 case OP_BIT_XOR:
1829 case OP_BIT_OR:
1830 case OP_CONCAT:
1831 case OP_SUBST:
1832 case OP_TRANS:
bb16bae8 1833 case OP_TRANSR:
49e9fbe6
GS		 1834 case OP_READ:
1835 case OP_SYSREAD:
1836 case OP_RECV:
bf4b1e52
GS		 1837 case OP_ANDASSIGN:
1838 case OP_ORASSIGN:
410d09fe 1839 case OP_DORASSIGN:
3fe9a6f1 1840 return TRUE;
1841 default:
1842 return FALSE;
1843 }
1844}
1845
35cd451c 1846STATIC bool
5f66b61c 1847S_is_handle_constructor(const OP *o, I32 numargs)
35cd451c 1848{
7918f24d
NC		 1849 PERL_ARGS_ASSERT_IS_HANDLE_CONSTRUCTOR;
1850
35cd451c
GS		 1851 switch (o->op_type) {
1852 case OP_PIPE_OP:
1853 case OP_SOCKPAIR:
504618e9 1854 if (numargs == 2)
35cd451c
GS		 1855 return TRUE;
1856 /* FALL THROUGH */
1857 case OP_SYSOPEN:
1858 case OP_OPEN:
ded8aa31 1859 case OP_SELECT: /* XXX c.f. SelectSaver.pm */
35cd451c
GS		 1860 case OP_SOCKET:
1861 case OP_OPEN_DIR:
1862 case OP_ACCEPT:
504618e9 1863 if (numargs == 1)
35cd451c 1864 return TRUE;
5f66b61c 1865 /* FALLTHROUGH */
35cd451c
GS		 1866 default:
1867 return FALSE;
1868 }
1869}
1870
0d86688d
NC		 1871static OP *
1872S_refkids(pTHX_ OP *o, I32 type)
463ee0b2 1873{
11343788 1874 if (o && o->op_flags & OPf_KIDS) {
6867be6d 1875 OP *kid;
11343788 1876 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
463ee0b2
LW		 1877 ref(kid, type);
1878 }
11343788 1879 return o;
463ee0b2
LW		 1880}
1881
1882OP *
e4c5ccf3 1883Perl_doref(pTHX_ OP *o, I32 type, bool set_op_ref)
463ee0b2 1884{
27da23d5 1885 dVAR;
463ee0b2 1886 OP *kid;
463ee0b2 1887
7918f24d
NC		 1888 PERL_ARGS_ASSERT_DOREF;
1889
13765c85 1890 if (!o || (PL_parser && PL_parser->error_count))
11343788 1891 return o;
463ee0b2 1892
11343788 1893 switch (o->op_type) {
a0d0e21e 1894 case OP_ENTERSUB:
afebc493 1895 if ((type == OP_EXISTS || type == OP_DEFINED || type == OP_LOCK) &&
11343788
MB		 1896 !(o->op_flags & OPf_STACKED)) {
1897 o->op_type = OP_RV2CV; /* entersub => rv2cv */
22c35a8c 1898 o->op_ppaddr = PL_ppaddr[OP_RV2CV];
11343788 1899 assert(cUNOPo->op_first->op_type == OP_NULL);
93c66552 1900 op_null(((LISTOP*)cUNOPo->op_first)->op_first); /* disable pushmark */
11343788 1901 o->op_flags |= OPf_SPECIAL;
e26df76a 1902 o->op_private &= ~1;
8990e307
LW		 1903 }
1904 break;
aeea060c 1905
463ee0b2 1906 case OP_COND_EXPR:
11343788 1907 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
e4c5ccf3 1908 doref(kid, type, set_op_ref);
463ee0b2 1909 break;
8990e307 1910 case OP_RV2SV:
35cd451c
GS		 1911 if (type == OP_DEFINED)
1912 o->op_flags |= OPf_SPECIAL; /* don't create GV */
e4c5ccf3 1913 doref(cUNOPo->op_first, o->op_type, set_op_ref);
4633a7c4
LW		 1914 /* FALL THROUGH */
1915 case OP_PADSV:
5f05dabc 1916 if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
5dc0d613
MB		 1917 o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1918 : type == OP_RV2HV ? OPpDEREF_HV
1919 : OPpDEREF_SV);
11343788 1920 o->op_flags |= OPf_MOD;
a0d0e21e 1921 }
8990e307 1922 break;
1c846c1f 1923
463ee0b2
LW		 1924 case OP_RV2AV:
1925 case OP_RV2HV:
e4c5ccf3
RH		 1926 if (set_op_ref)
1927 o->op_flags |= OPf_REF;
8990e307 1928 /* FALL THROUGH */
463ee0b2 1929 case OP_RV2GV:
35cd451c
GS		 1930 if (type == OP_DEFINED)
1931 o->op_flags |= OPf_SPECIAL; /* don't create GV */
e4c5ccf3 1932 doref(cUNOPo->op_first, o->op_type, set_op_ref);
463ee0b2 1933 break;
8990e307 1934
463ee0b2
LW		 1935 case OP_PADAV:
1936 case OP_PADHV:
e4c5ccf3
RH		 1937 if (set_op_ref)
1938 o->op_flags |= OPf_REF;
79072805 1939 break;
aeea060c 1940
8990e307 1941 case OP_SCALAR:
79072805 1942 case OP_NULL:
11343788 1943 if (!(o->op_flags & OPf_KIDS))
463ee0b2 1944 break;
e4c5ccf3 1945 doref(cBINOPo->op_first, type, set_op_ref);
79072805
LW		 1946 break;
1947 case OP_AELEM:
1948 case OP_HELEM:
e4c5ccf3 1949 doref(cBINOPo->op_first, o->op_type, set_op_ref);
5f05dabc 1950 if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
5dc0d613
MB		 1951 o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1952 : type == OP_RV2HV ? OPpDEREF_HV
1953 : OPpDEREF_SV);
11343788 1954 o->op_flags |= OPf_MOD;
8990e307 1955 }
79072805
LW		 1956 break;
1957
463ee0b2 1958 case OP_SCOPE:
79072805 1959 case OP_LEAVE:
e4c5ccf3
RH		 1960 set_op_ref = FALSE;
1961 /* FALL THROUGH */
79072805 1962 case OP_ENTER:
8990e307 1963 case OP_LIST:
11343788 1964 if (!(o->op_flags & OPf_KIDS))
79072805 1965 break;
e4c5ccf3 1966 doref(cLISTOPo->op_last, type, set_op_ref);
79072805 1967 break;
a0d0e21e
LW		 1968 default:
1969 break;
79072805 1970 }
11343788 1971 return scalar(o);
8990e307 1972
79072805
LW		 1973}
1974
09bef843
SB		 1975STATIC OP *
1976S_dup_attrlist(pTHX_ OP *o)
1977{
97aff369 1978 dVAR;
0bd48802 1979 OP *rop;
09bef843 1980
7918f24d
NC		 1981 PERL_ARGS_ASSERT_DUP_ATTRLIST;
1982
09bef843
SB		 1983 /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
1984 * where the first kid is OP_PUSHMARK and the remaining ones
1985 * are OP_CONST. We need to push the OP_CONST values.
1986 */
1987 if (o->op_type == OP_CONST)
b37c2d43 1988 rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc_NN(cSVOPo->op_sv));
eb8433b7
NC		 1989#ifdef PERL_MAD
1990 else if (o->op_type == OP_NULL)
1d866c12 1991 rop = NULL;
eb8433b7 1992#endif
09bef843
SB		 1993 else {
1994 assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
5f66b61c 1995 rop = NULL;
09bef843
SB		 1996 for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
1997 if (o->op_type == OP_CONST)
2fcb4757 1998 rop = op_append_elem(OP_LIST, rop,
09bef843 1999 newSVOP(OP_CONST, o->op_flags,
b37c2d43 2000 SvREFCNT_inc_NN(cSVOPo->op_sv)));
09bef843
SB		 2001 }
2002 }
2003 return rop;
2004}
2005
2006STATIC void
95f0a2f1 2007S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs, bool for_my)
09bef843 2008{
27da23d5 2009 dVAR;
09bef843
SB		 2010 SV *stashsv;
2011
7918f24d
NC		 2012 PERL_ARGS_ASSERT_APPLY_ATTRS;
2013
09bef843
SB		 2014 /* fake up C<use attributes $pkg,$rv,@attrs> */
2015 ENTER; /* need to protect against side-effects of 'use' */
5aaec2b4 2016 stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
e4783991 2017
09bef843 2018#define ATTRSMODULE "attributes"
95f0a2f1
SB		 2019#define ATTRSMODULE_PM "attributes.pm"
2020
2021 if (for_my) {
95f0a2f1 2022 /* Don't force the C<use> if we don't need it. */
a4fc7abc 2023 SV * const * const svp = hv_fetchs(GvHVn(PL_incgv), ATTRSMODULE_PM, FALSE);
95f0a2f1 2024 if (svp && *svp != &PL_sv_undef)
6f207bd3 2025 NOOP; /* already in %INC */
95f0a2f1
SB		 2026 else
2027 Perl_load_module(aTHX_ PERL_LOADMOD_NOIMPORT,
6136c704 2028 newSVpvs(ATTRSMODULE), NULL);
95f0a2f1
SB		 2029 }
2030 else {
2031 Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
6136c704
AL		 2032 newSVpvs(ATTRSMODULE),
2033 NULL,
2fcb4757 2034 op_prepend_elem(OP_LIST,
95f0a2f1 2035 newSVOP(OP_CONST, 0, stashsv),
2fcb4757 2036 op_prepend_elem(OP_LIST,
95f0a2f1
SB		 2037 newSVOP(OP_CONST, 0,
2038 newRV(target)),
2039 dup_attrlist(attrs))));
2040 }
09bef843
SB		 2041 LEAVE;
2042}
2043
95f0a2f1
SB		 2044STATIC void
2045S_apply_attrs_my(pTHX_ HV *stash, OP *target, OP *attrs, OP **imopsp)
2046{
97aff369 2047 dVAR;
95f0a2f1
SB		 2048 OP *pack, *imop, *arg;
2049 SV *meth, *stashsv;
2050
7918f24d
NC		 2051 PERL_ARGS_ASSERT_APPLY_ATTRS_MY;
2052
95f0a2f1
SB		 2053 if (!attrs)
2054 return;
2055
2056 assert(target->op_type == OP_PADSV ||
2057 target->op_type == OP_PADHV ||
2058 target->op_type == OP_PADAV);
2059
2060 /* Ensure that attributes.pm is loaded. */
dd2155a4 2061 apply_attrs(stash, PAD_SV(target->op_targ), attrs, TRUE);
95f0a2f1
SB		 2062
2063 /* Need package name for method call. */
6136c704 2064 pack = newSVOP(OP_CONST, 0, newSVpvs(ATTRSMODULE));
95f0a2f1
SB		 2065
2066 /* Build up the real arg-list. */
5aaec2b4
NC		 2067 stashsv = stash ? newSVhek(HvNAME_HEK(stash)) : &PL_sv_no;
2068
95f0a2f1
SB		 2069 arg = newOP(OP_PADSV, 0);
2070 arg->op_targ = target->op_targ;
2fcb4757 2071 arg = op_prepend_elem(OP_LIST,
95f0a2f1 2072 newSVOP(OP_CONST, 0, stashsv),
2fcb4757 2073 op_prepend_elem(OP_LIST,
95f0a2f1 2074 newUNOP(OP_REFGEN, 0,
3ad73efd 2075 op_lvalue(arg, OP_REFGEN)),
95f0a2f1
SB		 2076 dup_attrlist(attrs)));
2077
2078 /* Fake up a method call to import */
18916d0d 2079 meth = newSVpvs_share("import");
95f0a2f1 2080 imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL|OPf_WANT_VOID,
2fcb4757
Z		 2081 op_append_elem(OP_LIST,
2082 op_prepend_elem(OP_LIST, pack, list(arg)),
95f0a2f1
SB		 2083 newSVOP(OP_METHOD_NAMED, 0, meth)));
2084 imop->op_private |= OPpENTERSUB_NOMOD;
2085
2086 /* Combine the ops. */
2fcb4757 2087 *imopsp = op_append_elem(OP_LIST, *imopsp, imop);
95f0a2f1
SB		 2088}
2089
2090/*
2091=notfor apidoc apply_attrs_string
2092
2093Attempts to apply a list of attributes specified by the C<attrstr> and
2094C<len> arguments to the subroutine identified by the C<cv> argument which
2095is expected to be associated with the package identified by the C<stashpv>
2096argument (see L<attributes>). It gets this wrong, though, in that it
2097does not correctly identify the boundaries of the individual attribute
2098specifications within C<attrstr>. This is not really intended for the
2099public API, but has to be listed here for systems such as AIX which
2100need an explicit export list for symbols. (It's called from XS code
2101in support of the C<ATTRS:> keyword from F<xsubpp>.) Patches to fix it
2102to respect attribute syntax properly would be welcome.
2103
2104=cut
2105*/
2106
be3174d2 2107void
6867be6d
AL		 2108Perl_apply_attrs_string(pTHX_ const char *stashpv, CV *cv,
2109 const char *attrstr, STRLEN len)
be3174d2 2110{
5f66b61c 2111 OP *attrs = NULL;
be3174d2 2112
7918f24d
NC		 2113 PERL_ARGS_ASSERT_APPLY_ATTRS_STRING;
2114
be3174d2
GS		 2115 if (!len) {
2116 len = strlen(attrstr);
2117 }
2118
2119 while (len) {
2120 for (; isSPACE(*attrstr) && len; --len, ++attrstr) ;
2121 if (len) {
890ce7af 2122 const char * const sstr = attrstr;
be3174d2 2123 for (; !isSPACE(*attrstr) && len; --len, ++attrstr) ;
2fcb4757 2124 attrs = op_append_elem(OP_LIST, attrs,
be3174d2
GS		 2125 newSVOP(OP_CONST, 0,
2126 newSVpvn(sstr, attrstr-sstr)));
2127 }
2128 }
2129
2130 Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
6136c704 2131 newSVpvs(ATTRSMODULE),
2fcb4757 2132 NULL, op_prepend_elem(OP_LIST,
be3174d2 2133 newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
2fcb4757 2134 op_prepend_elem(OP_LIST,
be3174d2 2135 newSVOP(OP_CONST, 0,
ad64d0ec 2136 newRV(MUTABLE_SV(cv))),
be3174d2
GS		 2137 attrs)));
2138}
2139
09bef843 2140STATIC OP *
95f0a2f1 2141S_my_kid(pTHX_ OP *o, OP *attrs, OP **imopsp)
93a17b20 2142{
97aff369 2143 dVAR;
93a17b20
LW		 2144 I32 type;
2145
7918f24d
NC		 2146 PERL_ARGS_ASSERT_MY_KID;
2147
13765c85 2148 if (!o || (PL_parser && PL_parser->error_count))
11343788 2149 return o;
93a17b20 2150
bc61e325 2151 type = o->op_type;
eb8433b7
NC		 2152 if (PL_madskills && type == OP_NULL && o->op_flags & OPf_KIDS) {
2153 (void)my_kid(cUNOPo->op_first, attrs, imopsp);
2154 return o;
2155 }
2156
93a17b20 2157 if (type == OP_LIST) {
6867be6d 2158 OP *kid;
11343788 2159 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
95f0a2f1 2160 my_kid(kid, attrs, imopsp);
eb8433b7
NC		 2161 } else if (type == OP_UNDEF
2162#ifdef PERL_MAD
2163 || type == OP_STUB
2164#endif
2165 ) {
7766148a 2166 return o;
77ca0c92
LW		 2167 } else if (type == OP_RV2SV || /* "our" declaration */
2168 type == OP_RV2AV ||
2169 type == OP_RV2HV) { /* XXX does this let anything illegal in? */
1ce0b88c 2170 if (cUNOPo->op_first->op_type != OP_GV) { /* MJD 20011224 */
fab01b8e 2171 yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
952306ac 2172 OP_DESC(o),
12bd6ede
DM		 2173 PL_parser->in_my == KEY_our
2174 ? "our"
2175 : PL_parser->in_my == KEY_state ? "state" : "my"));
1ce0b88c 2176 } else if (attrs) {
551405c4 2177 GV * const gv = cGVOPx_gv(cUNOPo->op_first);
12bd6ede
DM		 2178 PL_parser->in_my = FALSE;
2179 PL_parser->in_my_stash = NULL;
1ce0b88c
RGS		 2180 apply_attrs(GvSTASH(gv),
2181 (type == OP_RV2SV ? GvSV(gv) :
ad64d0ec
NC		 2182 type == OP_RV2AV ? MUTABLE_SV(GvAV(gv)) :
2183 type == OP_RV2HV ? MUTABLE_SV(GvHV(gv)) : MUTABLE_SV(gv)),
1ce0b88c
RGS		 2184 attrs, FALSE);
2185 }
192587c2 2186 o->op_private |= OPpOUR_INTRO;
77ca0c92 2187 return o;
95f0a2f1
SB		 2188 }
2189 else if (type != OP_PADSV &&
93a17b20
LW		 2190 type != OP_PADAV &&
2191 type != OP_PADHV &&
2192 type != OP_PUSHMARK)
2193 {
eb64745e 2194 yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
53e06cf0 2195 OP_DESC(o),
12bd6ede
DM		 2196 PL_parser->in_my == KEY_our
2197 ? "our"
2198 : PL_parser->in_my == KEY_state ? "state" : "my"));
11343788 2199 return o;
93a17b20 2200 }
09bef843
SB		 2201 else if (attrs && type != OP_PUSHMARK) {
2202 HV *stash;
09bef843 2203
12bd6ede
DM		 2204 PL_parser->in_my = FALSE;
2205 PL_parser->in_my_stash = NULL;
eb64745e 2206
09bef843 2207 /* check for C<my Dog $spot> when deciding package */
dd2155a4
DM		 2208 stash = PAD_COMPNAME_TYPE(o->op_targ);
2209 if (!stash)
09bef843 2210 stash = PL_curstash;
95f0a2f1 2211 apply_attrs_my(stash, o, attrs, imopsp);
09bef843 2212 }
11343788
MB		 2213 o->op_flags |= OPf_MOD;
2214 o->op_private |= OPpLVAL_INTRO;
12bd6ede 2215 if (PL_parser->in_my == KEY_state)
952306ac 2216 o->op_private |= OPpPAD_STATE;
11343788 2217 return o;
93a17b20
LW		 2218}
2219
2220OP *
09bef843
SB		 2221Perl_my_attrs(pTHX_ OP *o, OP *attrs)
2222{
97aff369 2223 dVAR;
0bd48802 2224 OP *rops;
95f0a2f1
SB		 2225 int maybe_scalar = 0;
2226
7918f24d
NC		 2227 PERL_ARGS_ASSERT_MY_ATTRS;
2228
d2be0de5 2229/* [perl #17376]: this appears to be premature, and results in code such as
c754c3d7 2230 C< our(%x); > executing in list mode rather than void mode */
d2be0de5 2231#if 0
09bef843
SB		 2232 if (o->op_flags & OPf_PARENS)
2233 list(o);
95f0a2f1
SB		 2234 else
2235 maybe_scalar = 1;
d2be0de5
YST		 2236#else
2237 maybe_scalar = 1;
2238#endif
09bef843
SB		 2239 if (attrs)
2240 SAVEFREEOP(attrs);
5f66b61c 2241 rops = NULL;
95f0a2f1
SB		 2242 o = my_kid(o, attrs, &rops);
2243 if (rops) {
2244 if (maybe_scalar && o->op_type == OP_PADSV) {
2fcb4757 2245 o = scalar(op_append_list(OP_LIST, rops, o));
95f0a2f1
SB		 2246 o->op_private |= OPpLVAL_INTRO;
2247 }
2248 else
2fcb4757 2249 o = op_append_list(OP_LIST, o, rops);
95f0a2f1 2250 }
12bd6ede
DM		 2251 PL_parser->in_my = FALSE;
2252 PL_parser->in_my_stash = NULL;
eb64745e 2253 return o;
09bef843
SB		 2254}
2255
2256OP *
864dbfa3 2257Perl_sawparens(pTHX_ OP *o)
79072805 2258{
96a5add6 2259 PERL_UNUSED_CONTEXT;
79072805
LW		 2260 if (o)
2261 o->op_flags |= OPf_PARENS;
2262 return o;
2263}
2264
2265OP *
864dbfa3 2266Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
79072805 2267{
11343788 2268 OP *o;
59f00321 2269 bool ismatchop = 0;
1496a290
AL		 2270 const OPCODE ltype = left->op_type;
2271 const OPCODE rtype = right->op_type;
79072805 2272
7918f24d
NC		 2273 PERL_ARGS_ASSERT_BIND_MATCH;
2274
1496a290
AL		 2275 if ( (ltype == OP_RV2AV || ltype == OP_RV2HV || ltype == OP_PADAV
2276 || ltype == OP_PADHV) && ckWARN(WARN_MISC))
041457d9 2277 {
1496a290 2278 const char * const desc
bb16bae8
FC		 2279 = PL_op_desc[(
2280 rtype == OP_SUBST || rtype == OP_TRANS
2281 || rtype == OP_TRANSR
2282 )
666ea192
JH		 2283 ? (int)rtype : OP_MATCH];
2284 const char * const sample = ((ltype == OP_RV2AV || ltype == OP_PADAV)
2285 ? "@array" : "%hash");
9014280d 2286 Perl_warner(aTHX_ packWARN(WARN_MISC),
1c846c1f 2287 "Applying %s to %s will act on scalar(%s)",
599cee73 2288 desc, sample, sample);
2ae324a7 2289 }
2290
1496a290 2291 if (rtype == OP_CONST &&
5cc9e5c9
RH		 2292 cSVOPx(right)->op_private & OPpCONST_BARE &&
2293 cSVOPx(right)->op_private & OPpCONST_STRICT)
2294 {
2295 no_bareword_allowed(right);
2296 }
2297
bb16bae8 2298 /* !~ doesn't make sense with /r, so error on it for now */
4f4d7508
DC		 2299 if (rtype == OP_SUBST && (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT) &&
2300 type == OP_NOT)
2301 yyerror("Using !~ with s///r doesn't make sense");
bb16bae8
FC		 2302 if (rtype == OP_TRANSR && type == OP_NOT)
2303 yyerror("Using !~ with tr///r doesn't make sense");
4f4d7508 2304
2474a784
FC		 2305 ismatchop = (rtype == OP_MATCH ||
2306 rtype == OP_SUBST ||
bb16bae8 2307 rtype == OP_TRANS || rtype == OP_TRANSR)
2474a784 2308 && !(right->op_flags & OPf_SPECIAL);
59f00321
RGS		 2309 if (ismatchop && right->op_private & OPpTARGET_MY) {
2310 right->op_targ = 0;
2311 right->op_private &= ~OPpTARGET_MY;
2312 }
2313 if (!(right->op_flags & OPf_STACKED) && ismatchop) {
1496a290
AL		 2314 OP *newleft;
2315
79072805 2316 right->op_flags |= OPf_STACKED;
bb16bae8 2317 if (rtype != OP_MATCH && rtype != OP_TRANSR &&
1496a290 2318 ! (rtype == OP_TRANS &&
4f4d7508
DC		 2319 right->op_private & OPpTRANS_IDENTICAL) &&
2320 ! (rtype == OP_SUBST &&
2321 (cPMOPx(right)->op_pmflags & PMf_NONDESTRUCT)))
3ad73efd 2322 newleft = op_lvalue(left, rtype);
1496a290
AL		 2323 else
2324 newleft = left;
bb16bae8 2325 if (right->op_type == OP_TRANS || right->op_type == OP_TRANSR)
1496a290 2326 o = newBINOP(OP_NULL, OPf_STACKED, scalar(newleft), right);
79072805 2327 else
2fcb4757 2328 o = op_prepend_elem(rtype, scalar(newleft), right);
79072805 2329 if (type == OP_NOT)
11343788
MB		 2330 return newUNOP(OP_NOT, 0, scalar(o));
2331 return o;
79072805
LW		 2332 }
2333 else
2334 return bind_match(type, left,
131b3ad0 2335 pmruntime(newPMOP(OP_MATCH, 0), right, 0));
79072805
LW		 2336}
2337
2338OP *
864dbfa3 2339Perl_invert(pTHX_ OP *o)
79072805 2340{
11343788 2341 if (!o)
1d866c12 2342 return NULL;
11343788 2343 return newUNOP(OP_NOT, OPf_SPECIAL, scalar(o));
79072805
LW		 2344}
2345
3ad73efd
Z		 2346/*
2347=for apidoc Amx|OP *|op_scope|OP *o
2348
2349Wraps up an op tree with some additional ops so that at runtime a dynamic
2350scope will be created. The original ops run in the new dynamic scope,
2351and then, provided that they exit normally, the scope will be unwound.
2352The additional ops used to create and unwind the dynamic scope will
2353normally be an C<enter>/C<leave> pair, but a C<scope> op may be used
2354instead if the ops are simple enough to not need the full dynamic scope
2355structure.
2356
2357=cut
2358*/
2359
79072805 2360OP *
3ad73efd 2361Perl_op_scope(pTHX_ OP *o)
79072805 2362{
27da23d5 2363 dVAR;
79072805 2364 if (o) {
3280af22 2365 if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || PL_tainting) {
2fcb4757 2366 o = op_prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
463ee0b2 2367 o->op_type = OP_LEAVE;
22c35a8c 2368 o->op_ppaddr = PL_ppaddr[OP_LEAVE];
463ee0b2 2369 }
fdb22418
HS		 2370 else if (o->op_type == OP_LINESEQ) {
2371 OP *kid;
2372 o->op_type = OP_SCOPE;
2373 o->op_ppaddr = PL_ppaddr[OP_SCOPE];
2374 kid = ((LISTOP*)o)->op_first;
59110972 2375 if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE) {
fdb22418 2376 op_null(kid);
59110972
RH		 2377
2378 /* The following deals with things like 'do {1 for 1}' */
2379 kid = kid->op_sibling;
2380 if (kid &&
2381 (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE))
2382 op_null(kid);
2383 }
463ee0b2 2384 }
fdb22418 2385 else
5f66b61c 2386 o = newLISTOP(OP_SCOPE, 0, o, NULL);
79072805
LW		 2387 }
2388 return o;
2389}
1930840b 2390
a0d0e21e 2391int
864dbfa3 2392Perl_block_start(pTHX_ int full)
79072805 2393{
97aff369 2394 dVAR;
73d840c0 2395 const int retval = PL_savestack_ix;
1930840b 2396
dd2155a4 2397 pad_block_start(full);
b3ac6de7 2398 SAVEHINTS();
3280af22 2399 PL_hints &= ~HINT_BLOCK_SCOPE;
68da3b2f 2400 SAVECOMPILEWARNINGS();
72dc9ed5 2401 PL_compiling.cop_warnings = DUP_WARNINGS(PL_compiling.cop_warnings);
1930840b 2402
a88d97bf 2403 CALL_BLOCK_HOOKS(bhk_start, full);
1930840b 2404
a0d0e21e
LW		 2405 return retval;
2406}
2407
2408OP*
864dbfa3 2409Perl_block_end(pTHX_ I32 floor, OP *seq)
a0d0e21e 2410{
97aff369 2411 dVAR;
6867be6d 2412 const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
1930840b
BM		 2413 OP* retval = scalarseq(seq);
2414
a88d97bf 2415 CALL_BLOCK_HOOKS(bhk_pre_end, &retval);
1930840b 2416
e9818f4e 2417 LEAVE_SCOPE(floor);
623e6609 2418 CopHINTS_set(&PL_compiling, PL_hints);
a0d0e21e 2419 if (needblockscope)
3280af22 2420 PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
dd2155a4 2421 pad_leavemy();
1930840b 2422
a88d97bf 2423 CALL_BLOCK_HOOKS(bhk_post_end, &retval);
1930840b 2424
a0d0e21e
LW		 2425 return retval;
2426}
2427
fd85fad2
BM		 2428/*
2429=head1 Compile-time scope hooks
2430
2431=for apidoc Ao||blockhook_register
2432
2433Register a set of hooks to be called when the Perl lexical scope changes
2434at compile time. See L<perlguts/"Compile-time scope hooks">.
2435
2436=cut
2437*/
2438
bb6c22e7
BM		 2439void
2440Perl_blockhook_register(pTHX_ BHK *hk)
2441{
2442 PERL_ARGS_ASSERT_BLOCKHOOK_REGISTER;
2443
2444 Perl_av_create_and_push(aTHX_ &PL_blockhooks, newSViv(PTR2IV(hk)));
2445}
2446
76e3520e 2447STATIC OP *
cea2e8a9 2448S_newDEFSVOP(pTHX)
54b9620d 2449{
97aff369 2450 dVAR;
f8f98e0a 2451 const PADOFFSET offset = Perl_pad_findmy(aTHX_ STR_WITH_LEN("$_"), 0);
00b1698f 2452 if (offset == NOT_IN_PAD || PAD_COMPNAME_FLAGS_isOUR(offset)) {
59f00321
RGS		 2453 return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
2454 }
2455 else {
551405c4 2456 OP * const o = newOP(OP_PADSV, 0);
59f00321
RGS		 2457 o->op_targ = offset;
2458 return o;
2459 }
54b9620d
MB		 2460}
2461
a0d0e21e 2462void
864dbfa3 2463Perl_newPROG(pTHX_ OP *o)
a0d0e21e 2464{
97aff369 2465 dVAR;
7918f24d
NC		 2466
2467 PERL_ARGS_ASSERT_NEWPROG;
2468
3280af22 2469 if (PL_in_eval) {
b295d113
TH		 2470 if (PL_eval_root)
2471 return;
faef0170
HS		 2472 PL_eval_root = newUNOP(OP_LEAVEEVAL,
2473 ((PL_in_eval & EVAL_KEEPERR)
2474 ? OPf_SPECIAL : 0), o);
5983a79d
BM		 2475 /* don't use LINKLIST, since PL_eval_root might indirect through
2476 * a rather expensive function call and LINKLIST evaluates its
2477 * argument more than once */
2478 PL_eval_start = op_linklist(PL_eval_root);
7934575e
GS		 2479 PL_eval_root->op_private |= OPpREFCOUNTED;
2480 OpREFCNT_set(PL_eval_root, 1);
3280af22 2481 PL_eval_root->op_next = 0;
a2efc822 2482 CALL_PEEP(PL_eval_start);
a0d0e21e
LW		 2483 }
2484 else {
6be89cf9
AE		 2485 if (o->op_type == OP_STUB) {
2486 PL_comppad_name = 0;
2487 PL_compcv = 0;
d2c837a0 2488 S_op_destroy(aTHX_ o);
a0d0e21e 2489 return;
6be89cf9 2490 }
3ad73efd 2491 PL_main_root = op_scope(sawparens(scalarvoid(o)));
3280af22
NIS		 2492 PL_curcop = &PL_compiling;
2493 PL_main_start = LINKLIST(PL_main_root);
7934575e
GS		 2494 PL_main_root->op_private |= OPpREFCOUNTED;
2495 OpREFCNT_set(PL_main_root, 1);
3280af22 2496 PL_main_root->op_next = 0;
a2efc822 2497 CALL_PEEP(PL_main_start);
3280af22 2498 PL_compcv = 0;
3841441e 2499
4fdae800 2500 /* Register with debugger */
84902520 2501 if (PERLDB_INTER) {
b96d8cd9 2502 CV * const cv = get_cvs("DB::postponed", 0);
3841441e
CS		 2503 if (cv) {
2504 dSP;
924508f0 2505 PUSHMARK(SP);
ad64d0ec 2506 XPUSHs(MUTABLE_SV(CopFILEGV(&PL_compiling)));
3841441e 2507 PUTBACK;
ad64d0ec 2508 call_sv(MUTABLE_SV(cv), G_DISCARD);
3841441e
CS		 2509 }
2510 }
79072805 2511 }
79072805
LW		 2512}
2513
2514OP *
864dbfa3 2515Perl_localize(pTHX_ OP *o, I32 lex)
79072805 2516{
97aff369 2517 dVAR;
7918f24d
NC		 2518
2519 PERL_ARGS_ASSERT_LOCALIZE;
2520
79072805 2521 if (o->op_flags & OPf_PARENS)
d2be0de5
YST		 2522/* [perl #17376]: this appears to be premature, and results in code such as
2523 C< our(%x); > executing in list mode rather than void mode */
2524#if 0
79072805 2525 list(o);
d2be0de5 2526#else
6f207bd3 2527 NOOP;
d2be0de5 2528#endif
8990e307 2529 else {
f06b5848
DM		 2530 if ( PL_parser->bufptr > PL_parser->oldbufptr
2531 && PL_parser->bufptr[-1] == ','
041457d9 2532 && ckWARN(WARN_PARENTHESIS))
64420d0d 2533 {
f06b5848 2534 char *s = PL_parser->bufptr;
bac662ee 2535 bool sigil = FALSE;
64420d0d 2536
8473848f 2537 /* some heuristics to detect a potential error */
bac662ee 2538 while (*s && (strchr(", \t\n", *s)))
64420d0d 2539 s++;
8473848f 2540
bac662ee
TS		 2541 while (1) {
2542 if (*s && strchr("@$%*", *s) && *++s
2543 && (isALNUM(*s) || UTF8_IS_CONTINUED(*s))) {
2544 s++;
2545 sigil = TRUE;
2546 while (*s && (isALNUM(*s) || UTF8_IS_CONTINUED(*s)))
2547 s++;
2548 while (*s && (strchr(", \t\n", *s)))
2549 s++;
2550 }
2551 else
2552 break;
2553 }
2554 if (sigil && (*s == ';' || *s == '=')) {
2555 Perl_warner(aTHX_ packWARN(WARN_PARENTHESIS),
8473848f 2556 "Parentheses missing around \"%s\" list",
12bd6ede
DM		 2557 lex
2558 ? (PL_parser->in_my == KEY_our
2559 ? "our"
2560 : PL_parser->in_my == KEY_state
2561 ? "state"
2562 : "my")
2563 : "local");
8473848f 2564 }
8990e307
LW		 2565 }
2566 }
93a17b20 2567 if (lex)
eb64745e 2568 o = my(o);
93a17b20 2569 else
3ad73efd 2570 o = op_lvalue(o, OP_NULL); /* a bit kludgey */
12bd6ede
DM		 2571 PL_parser->in_my = FALSE;
2572 PL_parser->in_my_stash = NULL;
eb64745e 2573 return o;
79072805
LW		 2574}
2575
2576OP *
864dbfa3 2577Perl_jmaybe(pTHX_ OP *o)
79072805 2578{
7918f24d
NC		 2579 PERL_ARGS_ASSERT_JMAYBE;
2580
79072805 2581 if (o->op_type == OP_LIST) {
fafc274c 2582 OP * const o2
d4c19fe8 2583 = newSVREF(newGVOP(OP_GV, 0, gv_fetchpvs(";", GV_ADD|GV_NOTQUAL, SVt_PV)));
2fcb4757 2584 o = convert(OP_JOIN, 0, op_prepend_elem(OP_LIST, o2, o));
79072805
LW		 2585 }
2586 return o;
2587}
2588
1f676739 2589static OP *
b7783a12 2590S_fold_constants(pTHX_ register OP *o)
79072805 2591{
27da23d5 2592 dVAR;
001d637e 2593 register OP * VOL curop;
eb8433b7 2594 OP *newop;
8ea43dc8 2595 VOL I32 type = o->op_type;
e3cbe32f 2596 SV * VOL sv = NULL;
b7f7fd0b
NC		 2597 int ret = 0;
2598 I32 oldscope;
2599 OP *old_next;
5f2d9966
DM		 2600 SV * const oldwarnhook = PL_warnhook;
2601 SV * const olddiehook = PL_diehook;
c427f4d2 2602 COP not_compiling;
b7f7fd0b 2603 dJMPENV;
79072805 2604
7918f24d
NC		 2605 PERL_ARGS_ASSERT_FOLD_CONSTANTS;
2606
22c35a8c 2607 if (PL_opargs[type] & OA_RETSCALAR)
79072805 2608 scalar(o);
b162f9ea 2609 if (PL_opargs[type] & OA_TARGET && !o->op_targ)
ed6116ce 2610 o->op_targ = pad_alloc(type, SVs_PADTMP);
79072805 2611
eac055e9
GS		 2612 /* integerize op, unless it happens to be C<-foo>.
2613 * XXX should pp_i_negate() do magic string negation instead? */
2614 if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER)
2615 && !(type == OP_NEGATE && cUNOPo->op_first->op_type == OP_CONST
2616 && (cUNOPo->op_first->op_private & OPpCONST_BARE)))
2617 {
22c35a8c 2618 o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)];
eac055e9 2619 }
85e6fe83 2620
22c35a8c 2621 if (!(PL_opargs[type] & OA_FOLDCONST))
79072805
LW		 2622 goto nope;
2623
de939608 2624 switch (type) {
7a52d87a
GS		 2625 case OP_NEGATE:
2626 /* XXX might want a ck_negate() for this */
2627 cUNOPo->op_first->op_private &= ~OPpCONST_STRICT;
2628 break;
de939608
CS		 2629 case OP_UCFIRST:
2630 case OP_LCFIRST:
2631 case OP_UC:
2632 case OP_LC:
69dcf70c
MB		 2633 case OP_SLT:
2634 case OP_SGT:
2635 case OP_SLE:
2636 case OP_SGE:
2637 case OP_SCMP:
b3fd6149 2638 case OP_SPRINTF:
2de3dbcc
JH		 2639 /* XXX what about the numeric ops? */
2640 if (PL_hints & HINT_LOCALE)
de939608 2641 goto nope;
553e7bb0 2642 break;
de939608
CS		 2643 }
2644
13765c85 2645 if (PL_parser && PL_parser->error_count)
a0d0e21e
LW		 2646 goto nope; /* Don't try to run w/ errors */
2647
79072805 2648 for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
1496a290
AL		 2649 const OPCODE type = curop->op_type;
2650 if ((type != OP_CONST || (curop->op_private & OPpCONST_BARE)) &&
2651 type != OP_LIST &&
2652 type != OP_SCALAR &&
2653 type != OP_NULL &&
2654 type != OP_PUSHMARK)
7a52d87a 2655 {
79072805
LW		 2656 goto nope;
2657 }
2658 }
2659
2660 curop = LINKLIST(o);
b7f7fd0b 2661 old_next = o->op_next;
79072805 2662 o->op_next = 0;
533c011a 2663 PL_op = curop;
b7f7fd0b
NC		 2664
2665 oldscope = PL_scopestack_ix;
edb2152a 2666 create_eval_scope(G_FAKINGEVAL);
b7f7fd0b 2667
c427f4d2
NC		 2668 /* Verify that we don't need to save it: */
2669 assert(PL_curcop == &PL_compiling);
2670 StructCopy(&PL_compiling, &not_compiling, COP);
2671 PL_curcop = &not_compiling;
2672 /* The above ensures that we run with all the correct hints of the
2673 currently compiling COP, but that IN_PERL_RUNTIME is not true. */
2674 assert(IN_PERL_RUNTIME);
5f2d9966
DM		 2675 PL_warnhook = PERL_WARNHOOK_FATAL;
2676 PL_diehook = NULL;
b7f7fd0b
NC		 2677 JMPENV_PUSH(ret);
2678
2679 switch (ret) {
2680 case 0:
2681 CALLRUNOPS(aTHX);
2682 sv = *(PL_stack_sp--);
2683 if (o->op_targ && sv == PAD_SV(o->op_targ)) /* grab pad temp? */
2684 pad_swipe(o->op_targ, FALSE);
2685 else if (SvTEMP(sv)) { /* grab mortal temp? */
2686 SvREFCNT_inc_simple_void(sv);
2687 SvTEMP_off(sv);
2688 }
2689 break;
2690 case 3:
2691 /* Something tried to die. Abandon constant folding. */
2692 /* Pretend the error never happened. */
ab69dbc2 2693 CLEAR_ERRSV();
b7f7fd0b
NC		 2694 o->op_next = old_next;
2695 break;
2696 default:
2697 JMPENV_POP;
5f2d9966
DM		 2698 /* Don't expect 1 (setjmp failed) or 2 (something called my_exit) */
2699 PL_warnhook = oldwarnhook;
2700 PL_diehook = olddiehook;
2701 /* XXX note that this croak may fail as we've already blown away
2702 * the stack - eg any nested evals */
b7f7fd0b
NC		 2703 Perl_croak(aTHX_ "panic: fold_constants JMPENV_PUSH returned %d", ret);
2704 }
b7f7fd0b 2705 JMPENV_POP;
5f2d9966
DM		 2706 PL_warnhook = oldwarnhook;
2707 PL_diehook = olddiehook;
c427f4d2 2708 PL_curcop = &PL_compiling;
edb2152a
NC		 2709
2710 if (PL_scopestack_ix > oldscope)
2711 delete_eval_scope();
eb8433b7 2712
b7f7fd0b
NC		 2713 if (ret)
2714 goto nope;
2715
eb8433b7 2716#ifndef PERL_MAD
79072805 2717 op_free(o);
eb8433b7 2718#endif
de5e01c2 2719 assert(sv);
79072805 2720 if (type == OP_RV2GV)
159b6efe 2721 newop = newGVOP(OP_GV, 0, MUTABLE_GV(sv));
eb8433b7 2722 else
ad64d0ec 2723 newop = newSVOP(OP_CONST, 0, MUTABLE_SV(sv));
eb8433b7
NC		 2724 op_getmad(o,newop,'f');
2725 return newop;
aeea060c 2726
b7f7fd0b 2727 nope:
79072805
LW		 2728 return o;
2729}
2730
1f676739 2731static OP *
b7783a12 2732S_gen_constant_list(pTHX_ register OP *o)
79072805 2733{
27da23d5 2734 dVAR;
79072805 2735 register OP *curop;
6867be6d 2736 const I32 oldtmps_floor = PL_tmps_floor;
79072805 2737
a0d0e21e 2738 list(o);
13765c85 2739 if (PL_parser && PL_parser->error_count)
a0d0e21e
LW		 2740 return o; /* Don't attempt to run with errors */
2741
533c011a 2742 PL_op = curop = LINKLIST(o);
a0d0e21e 2743 o->op_next = 0;
a2efc822 2744 CALL_PEEP(curop);
cea2e8a9
GS		 2745 pp_pushmark();
2746 CALLRUNOPS(aTHX);
533c011a 2747 PL_op = curop;
78c72037
NC		 2748 assert (!(curop->op_flags & OPf_SPECIAL));
2749 assert(curop->op_type == OP_RANGE);
cea2e8a9 2750 pp_anonlist();
3280af22 2751 PL_tmps_floor = oldtmps_floor;
79072805
LW		 2752
2753 o->op_type = OP_RV2AV;
22c35a8c 2754 o->op_ppaddr = PL_ppaddr[OP_RV2AV];
fb53bbb2
SG		 2755 o->op_flags &= ~OPf_REF; /* treat \(1..2) like an ordinary list */
2756 o->op_flags |= OPf_PARENS; /* and flatten \(1..2,3) */
1a0a2ba9 2757 o->op_opt = 0; /* needs to be revisited in rpeep() */
79072805 2758 curop = ((UNOP*)o)->op_first;
b37c2d43 2759 ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc_NN(*PL_stack_sp--));
eb8433b7
NC		 2760#ifdef PERL_MAD
2761 op_getmad(curop,o,'O');
2762#else
79072805 2763 op_free(curop);
eb8433b7 2764#endif
5983a79d 2765 LINKLIST(o);
79072805
LW		 2766 return list(o);
2767}
2768
2769OP *
864dbfa3 2770Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
79072805 2771{
27da23d5 2772 dVAR;
11343788 2773 if (!o || o->op_type != OP_LIST)
5f66b61c 2774 o = newLISTOP(OP_LIST, 0, o, NULL);
748a9306 2775 else
5dc0d613 2776 o->op_flags &= ~OPf_WANT;
79072805 2777
22c35a8c 2778 if (!(PL_opargs[type] & OA_MARK))
93c66552 2779 op_null(cLISTOPo->op_first);
8990e307 2780
eb160463 2781 o->op_type = (OPCODE)type;
22c35a8c 2782 o->op_ppaddr = PL_ppaddr[type];
11343788 2783 o->op_flags |= flags;
79072805 2784
11343788 2785 o = CHECKOP(type, o);
fe2774ed 2786 if (o->op_type != (unsigned)type)
11343788 2787 return o;
79072805 2788
11343788 2789 return fold_constants(o);
79072805
LW		 2790}
2791
2fcb4757
Z		 2792/*
2793=head1 Optree Manipulation Functions
2794*/
2795
79072805
LW		 2796/* List constructors */
2797
2fcb4757
Z		 2798/*
2799=for apidoc Am|OP *|op_append_elem|I32 optype|OP *first|OP *last
2800
2801Append an item to the list of ops contained directly within a list-type
2802op, returning the lengthened list. I<first> is the list-type op,
2803and I<last> is the op to append to the list. I<optype> specifies the
2804intended opcode for the list. If I<first> is not already a list of the
2805right type, it will be upgraded into one. If either I<first> or I<last>
2806is null, the other is returned unchanged.
2807
2808=cut
2809*/
2810
79072805 2811OP *
2fcb4757 2812Perl_op_append_elem(pTHX_ I32 type, OP *first, OP *last)
79072805
LW		 2813{
2814 if (!first)
2815 return last;
8990e307
LW		 2816
2817 if (!last)
79072805 2818 return first;
8990e307 2819
fe2774ed 2820 if (first->op_type != (unsigned)type
155aba94
GS		 2821 || (type == OP_LIST && (first->op_flags & OPf_PARENS)))
2822 {
2823 return newLISTOP(type, 0, first, last);
2824 }
79072805 2825
a0d0e21e
LW		 2826 if (first->op_flags & OPf_KIDS)
2827 ((LISTOP*)first)->op_last->op_sibling = last;
2828 else {
2829 first->op_flags |= OPf_KIDS;
2830 ((LISTOP*)first)->op_first = last;
2831 }
2832 ((LISTOP*)first)->op_last = last;
a0d0e21e 2833 return first;
79072805
LW		 2834}
2835
2fcb4757
Z		 2836/*
2837=for apidoc Am|OP *|op_append_list|I32 optype|OP *first|OP *last
2838
2839Concatenate the lists of ops contained directly within two list-type ops,
2840returning the combined list. I<first> and I<last> are the list-type ops
2841to concatenate. I<optype> specifies the intended opcode for the list.
2842If either I<first> or I<last> is not already a list of the right type,
2843it will be upgraded into one. If either I<first> or I<last> is null,
2844the other is returned unchanged.
2845
2846=cut
2847*/
2848
79072805 2849OP *
2fcb4757 2850Perl_op_append_list(pTHX_ I32 type, OP *first, OP *last)
79072805
LW		 2851{
2852 if (!first)
2fcb4757 2853 return last;
8990e307
LW		 2854
2855 if (!last)
2fcb4757 2856 return first;
8990e307 2857
fe2774ed 2858 if (first->op_type != (unsigned)type)
2fcb4757 2859 return op_prepend_elem(type, first, last);
8990e307 2860
fe2774ed 2861 if (last->op_type != (unsigned)type)
2fcb4757 2862 return op_append_elem(type, first, last);
79072805 2863
2fcb4757
Z		 2864 ((LISTOP*)first)->op_last->op_sibling = ((LISTOP*)last)->op_first;
2865 ((LISTOP*)first)->op_last = ((LISTOP*)last)->op_last;
117dada2 2866 first->op_flags |= (last->op_flags & OPf_KIDS);
1c846c1f 2867
eb8433b7 2868#ifdef PERL_MAD
2fcb4757
Z		 2869 if (((LISTOP*)last)->op_first && first->op_madprop) {
2870 MADPROP *mp = ((LISTOP*)last)->op_first->op_madprop;
eb8433b7
NC		 2871 if (mp) {
2872 while (mp->mad_next)
2873 mp = mp->mad_next;
2874 mp->mad_next = first->op_madprop;
2875 }
2876 else {
2fcb4757 2877 ((LISTOP*)last)->op_first->op_madprop = first->op_madprop;
eb8433b7
NC		 2878 }
2879 }
2880 first->op_madprop = last->op_madprop;
2881 last->op_madprop = 0;
2882#endif
2883
2fcb4757 2884 S_op_destroy(aTHX_ last);
238a4c30 2885
2fcb4757 2886 return first;
79072805
LW		 2887}
2888
2fcb4757
Z		 2889/*
2890=for apidoc Am|OP *|op_prepend_elem|I32 optype|OP *first|OP *last
2891
2892Prepend an item to the list of ops contained directly within a list-type
2893op, returning the lengthened list. I<first> is the op to prepend to the
2894list, and I<last> is the list-type op. I<optype> specifies the intended
2895opcode for the list. If I<last> is not already a list of the right type,
2896it will be upgraded into one. If either I<first> or I<last> is null,
2897the other is returned unchanged.
2898
2899=cut
2900*/
2901
79072805 2902OP *
2fcb4757 2903Perl_op_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
79072805
LW		 2904{
2905 if (!first)
2906 return last;
8990e307
LW		 2907
2908 if (!last)
79072805 2909 return first;
8990e307 2910
fe2774ed 2911 if (last->op_type == (unsigned)type) {
8990e307
LW		 2912 if (type == OP_LIST) { /* already a PUSHMARK there */
2913 first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
2914 ((LISTOP*)last)->op_first->op_sibling = first;
36a5d4ba
DC		 2915 if (!(first->op_flags & OPf_PARENS))
2916 last->op_flags &= ~OPf_PARENS;
8990e307
LW		 2917 }
2918 else {
2919 if (!(last->op_flags & OPf_KIDS)) {
2920 ((LISTOP*)last)->op_last = first;
2921 last->op_flags |= OPf_KIDS;
2922 }
2923 first->op_sibling = ((LISTOP*)last)->op_first;
2924 ((LISTOP*)last)->op_first = first;
79072805 2925 }
117dada2 2926 last->op_flags |= OPf_KIDS;
79072805
LW		 2927 return last;
2928 }
2929
2930 return newLISTOP(type, 0, first, last);
2931}
2932
2933/* Constructors */
2934
eb8433b7
NC		 2935#ifdef PERL_MAD
2936
2937TOKEN *
2938Perl_newTOKEN(pTHX_ I32 optype, YYSTYPE lval, MADPROP* madprop)
2939{
2940 TOKEN *tk;
99129197 2941 Newxz(tk, 1, TOKEN);
eb8433b7
NC		 2942 tk->tk_type = (OPCODE)optype;
2943 tk->tk_type = 12345;
2944 tk->tk_lval = lval;
2945 tk->tk_mad = madprop;
2946 return tk;
2947}
2948
2949void
2950Perl_token_free(pTHX_ TOKEN* tk)
2951{
7918f24d
NC		 2952 PERL_ARGS_ASSERT_TOKEN_FREE;
2953
eb8433b7
NC		 2954 if (tk->tk_type != 12345)
2955 return;
2956 mad_free(tk->tk_mad);
2957 Safefree(tk);
2958}
2959
2960void
2961Perl_token_getmad(pTHX_ TOKEN* tk, OP* o, char slot)
2962{
2963 MADPROP* mp;
2964 MADPROP* tm;
7918f24d
NC		 2965
2966 PERL_ARGS_ASSERT_TOKEN_GETMAD;
2967
eb8433b7
NC		 2968 if (tk->tk_type != 12345) {
2969 Perl_warner(aTHX_ packWARN(WARN_MISC),
2970 "Invalid TOKEN object ignored");
2971 return;
2972 }
2973 tm = tk->tk_mad;
2974 if (!tm)
2975 return;
2976
2977 /* faked up qw list? */
2978 if (slot == '(' &&
2979 tm->mad_type == MAD_SV &&
d503a9ba 2980 SvPVX((SV *)tm->mad_val)[0] == 'q')
eb8433b7
NC		 2981 slot = 'x';
2982
2983 if (o) {
2984 mp = o->op_madprop;
2985 if (mp) {
2986 for (;;) {
2987 /* pretend constant fold didn't happen? */
2988 if (mp->mad_key == 'f' &&
2989 (o->op_type == OP_CONST ||
2990 o->op_type == OP_GV) )
2991 {
2992 token_getmad(tk,(OP*)mp->mad_val,slot);
2993 return;
2994 }
2995 if (!mp->mad_next)
2996 break;
2997 mp = mp->mad_next;
2998 }
2999 mp->mad_next = tm;
3000 mp = mp->mad_next;
3001 }
3002 else {
3003 o->op_madprop = tm;
3004 mp = o->op_madprop;
3005 }
3006 if (mp->mad_key == 'X')
3007 mp->mad_key = slot; /* just change the first one */
3008
3009 tk->tk_mad = 0;
3010 }
3011 else
3012 mad_free(tm);
3013 Safefree(tk);
3014}
3015
3016void
3017Perl_op_getmad_weak(pTHX_ OP* from, OP* o, char slot)
3018{
3019 MADPROP* mp;
3020 if (!from)
3021 return;
3022 if (o) {
3023 mp = o->op_madprop;
3024 if (mp) {
3025 for (;;) {
3026 /* pretend constant fold didn't happen? */
3027 if (mp->mad_key == 'f' &&
3028 (o->op_type == OP_CONST ||
3029 o->op_type == OP_GV) )
3030 {
3031 op_getmad(from,(OP*)mp->mad_val,slot);
3032 return;
3033 }
3034 if (!mp->mad_next)
3035 break;
3036 mp = mp->mad_next;
3037 }
3038 mp->mad_next = newMADPROP(slot,MAD_OP,from,0);
3039 }
3040 else {
3041 o->op_madprop = newMADPROP(slot,MAD_OP,from,0);
3042 }
3043 }
3044}
3045
3046void
3047Perl_op_getmad(pTHX_ OP* from, OP* o, char slot)
3048{
3049 MADPROP* mp;
3050 if (!from)
3051 return;
3052 if (o) {
3053 mp = o->op_madprop;
3054 if (mp) {
3055 for (;;) {
3056 /* pretend constant fold didn't happen? */
3057 if (mp->mad_key == 'f' &&
3058 (o->op_type == OP_CONST ||
3059 o->op_type == OP_GV) )
3060 {
3061 op_getmad(from,(OP*)mp->mad_val,slot);
3062 return;
3063 }
3064 if (!mp->mad_next)
3065 break;
3066 mp = mp->mad_next;
3067 }
3068 mp->mad_next = newMADPROP(slot,MAD_OP,from,1);
3069 }
3070 else {
3071 o->op_madprop = newMADPROP(slot,MAD_OP,from,1);
3072 }
3073 }
3074 else {
99129197
NC		 3075 PerlIO_printf(PerlIO_stderr(),
3076 "DESTROYING op = %0"UVxf"\n", PTR2UV(from));
eb8433b7
NC		 3077 op_free(from);
3078 }
3079}
3080
3081void
3082Perl_prepend_madprops(pTHX_ MADPROP* mp, OP* o, char slot)
3083{
3084 MADPROP* tm;
3085 if (!mp || !o)
3086 return;
3087 if (slot)
3088 mp->mad_key = slot;
3089 tm = o->op_madprop;
3090 o->op_madprop = mp;
3091 for (;;) {
3092 if (!mp->mad_next)
3093 break;
3094 mp = mp->mad_next;
3095 }
3096 mp->mad_next = tm;
3097}
3098
3099void
3100Perl_append_madprops(pTHX_ MADPROP* tm, OP* o, char slot)
3101{
3102 if (!o)
3103 return;
3104 addmad(tm, &(o->op_madprop), slot);
3105}
3106
3107void
3108Perl_addmad(pTHX_ MADPROP* tm, MADPROP** root, char slot)
3109{
3110 MADPROP* mp;
3111 if (!tm || !root)
3112 return;
3113 if (slot)
3114 tm->mad_key = slot;
3115 mp = *root;
3116 if (!mp) {
3117 *root = tm;
3118 return;
3119 }
3120 for (;;) {
3121 if (!mp->mad_next)
3122 break;
3123 mp = mp->mad_next;
3124 }
3125 mp->mad_next = tm;
3126}
3127
3128MADPROP *
3129Perl_newMADsv(pTHX_ char key, SV* sv)
3130{
7918f24d
NC		 3131 PERL_ARGS_ASSERT_NEWMADSV;
3132
eb8433b7
NC		 3133 return newMADPROP(key, MAD_SV, sv, 0);
3134}
3135
3136MADPROP *
d503a9ba 3137Perl_newMADPROP(pTHX_ char key, char type, void* val, I32 vlen)
eb8433b7
NC		 3138{
3139 MADPROP *mp;
99129197 3140 Newxz(mp, 1, MADPROP);
eb8433b7
NC		 3141 mp->mad_next = 0;
3142 mp->mad_key = key;
3143 mp->mad_vlen = vlen;
3144 mp->mad_type = type;
3145 mp->mad_val = val;
3146/* PerlIO_printf(PerlIO_stderr(), "NEW mp = %0x\n", mp); */
3147 return mp;
3148}
3149
3150void
3151Perl_mad_free(pTHX_ MADPROP* mp)
3152{
3153/* PerlIO_printf(PerlIO_stderr(), "FREE mp = %0x\n", mp); */
3154 if (!mp)
3155 return;
3156 if (mp->mad_next)
3157 mad_free(mp->mad_next);
bc177e6b 3158/* if (PL_parser && PL_parser->lex_state != LEX_NOTPARSING && mp->mad_vlen)
eb8433b7
NC		 3159 PerlIO_printf(PerlIO_stderr(), "DESTROYING '%c'=<%s>\n", mp->mad_key & 255, mp->mad_val); */
3160 switch (mp->mad_type) {
3161 case MAD_NULL:
3162 break;
3163 case MAD_PV:
3164 Safefree((char*)mp->mad_val);
3165 break;
3166 case MAD_OP:
3167 if (mp->mad_vlen) /* vlen holds "strong/weak" boolean */
3168 op_free((OP*)mp->mad_val);
3169 break;
3170 case MAD_SV:
ad64d0ec 3171 sv_free(MUTABLE_SV(mp->mad_val));
eb8433b7
NC		 3172 break;
3173 default:
3174 PerlIO_printf(PerlIO_stderr(), "Unrecognized mad\n");
3175 break;
3176 }
3177 Safefree(mp);
3178}
3179
3180#endif
3181
d67eb5f4
Z		 3182/*
3183=head1 Optree construction
3184
3185=for apidoc Am|OP *|newNULLLIST
3186
3187Constructs, checks, and returns a new C<stub> op, which represents an
3188empty list expression.
3189
3190=cut
3191*/
3192
79072805 3193OP *
864dbfa3 3194Perl_newNULLLIST(pTHX)
79072805 3195{
8990e307
LW		 3196 return newOP(OP_STUB, 0);
3197}
3198
1f676739 3199static OP *
b7783a12 3200S_force_list(pTHX_ OP *o)
8990e307 3201{
11343788 3202 if (!o || o->op_type != OP_LIST)
5f66b61c 3203 o = newLISTOP(OP_LIST, 0, o, NULL);
93c66552 3204 op_null(o);
11343788 3205 return o;
79072805
LW		 3206}
3207
d67eb5f4
Z		 3208/*
3209=for apidoc Am|OP *|newLISTOP|I32 type|I32 flags|OP *first|OP *last
3210
3211Constructs, checks, and returns an op of any list type. I<type> is
3212the opcode. I<flags> gives the eight bits of C<op_flags>, except that
3213C<OPf_KIDS> will be set automatically if required. I<first> and I<last>
3214supply up to two ops to be direct children of the list op; they are
3215consumed by this function and become part of the constructed op tree.
3216
3217=cut
3218*/
3219
79072805 3220OP *
864dbfa3 3221Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
79072805 3222{
27da23d5 3223 dVAR;
79072805
LW		 3224 LISTOP *listop;
3225
e69777c1
GG		 3226 assert((PL_opargs[type] & OA_CLASS_MASK) == OA_LISTOP);
3227
b7dc083c 3228 NewOp(1101, listop, 1, LISTOP);
79072805 3229
eb160463 3230 listop->op_type = (OPCODE)type;
22c35a8c 3231 listop->op_ppaddr = PL_ppaddr[type];
117dada2
SM		 3232 if (first || last)
3233 flags |= OPf_KIDS;
eb160463 3234 listop->op_flags = (U8)flags;
79072805
LW		 3235
3236 if (!last && first)
3237 last = first;
3238 else if (!first && last)
3239 first = last;
8990e307
LW		 3240 else if (first)
3241 first->op_sibling = last;
79072805
LW		 3242 listop->op_first = first;
3243 listop->op_last = last;
8990e307 3244 if (type == OP_LIST) {
551405c4 3245 OP* const pushop = newOP(OP_PUSHMARK, 0);
8990e307
LW		 3246 pushop->op_sibling = first;
3247 listop->op_first = pushop;
3248 listop->op_flags |= OPf_KIDS;
3249 if (!last)
3250 listop->op_last = pushop;
3251 }
79072805 3252
463d09e6 3253 return CHECKOP(type, listop);
79072805
LW		 3254}
3255
d67eb5f4
Z		 3256/*
3257=for apidoc Am|OP *|newOP|I32 type|I32 flags
3258
3259Constructs, checks, and returns an op of any base type (any type that
3260has no extra fields). I<type> is the opcode. I<flags> gives the
3261eight bits of C<op_flags>, and, shifted up eight bits, the eight bits
3262of C<op_private>.
3263
3264=cut
3265*/
3266
79072805 3267OP *
864dbfa3 3268Perl_newOP(pTHX_ I32 type, I32 flags)
79072805 3269{
27da23d5 3270 dVAR;
11343788 3271 OP *o;
e69777c1
GG		 3272
3273 assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP
3274 || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
3275 || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
3276 || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP);
3277
b7dc083c 3278 NewOp(1101, o, 1, OP);
eb160463 3279 o->op_type = (OPCODE)type;
22c35a8c 3280 o->op_ppaddr = PL_ppaddr[type];
eb160463 3281 o->op_flags = (U8)flags;
670f3923
DM		 3282 o->op_latefree = 0;
3283 o->op_latefreed = 0;
7e5d8ed2 3284 o->op_attached = 0;
79072805 3285
11343788 3286 o->op_next = o;
eb160463 3287 o->op_private = (U8)(0 | (flags >> 8));
22c35a8c 3288 if (PL_opargs[type] & OA_RETSCALAR)
11343788 3289 scalar(o);
22c35a8c 3290 if (PL_opargs[type] & OA_TARGET)
11343788
MB		 3291 o->op_targ = pad_alloc(type, SVs_PADTMP);
3292 return CHECKOP(type, o);
79072805
LW		 3293}
3294
d67eb5f4
Z		 3295/*
3296=for apidoc Am|OP *|newUNOP|I32 type|I32 flags|OP *first
3297
3298Constructs, checks, and returns an op of any unary type. I<type> is
3299the opcode. I<flags> gives the eight bits of C<op_flags>, except that
3300C<OPf_KIDS> will be set automatically if required, and, shifted up eight
3301bits, the eight bits of C<op_private>, except that the bit with value 1
3302is automatically set. I<first> supplies an optional op to be the direct
3303child of the unary op; it is consumed by this function and become part
3304of the constructed op tree.
3305
3306=cut
3307*/
3308
79072805 3309OP *
864dbfa3 3310Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
79072805 3311{
27da23d5 3312 dVAR;
79072805
LW		 3313 UNOP *unop;
3314
e69777c1
GG		 3315 assert((PL_opargs[type] & OA_CLASS_MASK) == OA_UNOP
3316 || (PL_opargs[type] & OA_CLASS_MASK) == OA_BASEOP_OR_UNOP
3317 || (PL_opargs[type] & OA_CLASS_MASK) == OA_FILESTATOP
3318 || (PL_opargs[type] & OA_CLASS_MASK) == OA_LOOPEXOP
3319 || type == OP_SASSIGN
32e2a35d 3320 || type == OP_ENTERTRY
e69777c1
GG		 3321 || type == OP_NULL );
3322
93a17b20 3323 if (!first)
aeea060c 3324 first = newOP(OP_STUB, 0);
22c35a8c 3325 if (PL_opargs[type] & OA_MARK)
8990e307 3326 first = force_list(first);
93a17b20 3327
b7dc083c 3328 NewOp(1101, unop, 1, UNOP);
eb160463 3329 unop->op_type = (OPCODE)type;
22c35a8c 3330 unop->op_ppaddr = PL_ppaddr[type];
79072805 3331 unop->op_first = first;
585ec06d 3332 unop->op_flags = (U8)(flags | OPf_KIDS);
eb160463 3333 unop->op_private = (U8)(1 | (flags >> 8));
e50aee73 3334 unop = (UNOP*) CHECKOP(type, unop);
79072805
LW		 3335 if (unop->op_next)
3336 return (OP*)unop;
3337
a0d0e21e 3338 return fold_constants((OP *) unop);
79072805
LW		 3339}
3340
d67eb5f4
Z		 3341/*
3342=for apidoc Am|OP *|newBINOP|I32 type|I32 flags|OP *first|OP *last
3343
3344Constructs, checks, and returns an op of any binary type. I<type>
3345is the opcode. I<flags> gives the eight bits of C<op_flags>, except
3346that C<OPf_KIDS> will be set automatically, and, shifted up eight bits,
3347the eight bits of C<op_private>, except that the bit with value 1 or
33482 is automatically set as required. I<first> and I<last> supply up to
3349two ops to be the direct children of the binary op; they are consumed
3350by this function and become part of the constructed op tree.
3351
3352=cut
3353*/
3354
79072805 3355OP *
864dbfa3 3356Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
79072805 3357{
27da23d5 3358 dVAR;
79072805 3359 BINOP *binop;
e69777c1
GG		 3360
3361 assert((PL_opargs[type] & OA_CLASS_MASK) == OA_BINOP
3362 || type == OP_SASSIGN || type == OP_NULL );
3363
b7dc083c 3364 NewOp(1101, binop, 1, BINOP);
79072805
LW		 3365
3366 if (!first)
3367 first = newOP(OP_NULL, 0);
3368
eb160463 3369 binop->op_type = (OPCODE)type;
22c35a8c 3370 binop->op_ppaddr = PL_ppaddr[type];
79072805 3371 binop->op_first = first;
585ec06d 3372 binop->op_flags = (U8)(flags | OPf_KIDS);
79072805
LW		 3373 if (!last) {
3374 last = first;
eb160463 3375 binop->op_private = (U8)(1 | (flags >> 8));
79072805
LW		 3376 }
3377 else {
eb160463 3378 binop->op_private = (U8)(2 | (flags >> 8));
79072805
LW		 3379 first->op_sibling = last;
3380 }
3381
e50aee73 3382 binop = (BINOP*)CHECKOP(type, binop);
eb160463 3383 if (binop->op_next || binop->op_type != (OPCODE)type)
79072805
LW		 3384 return (OP*)binop;
3385
7284ab6f 3386 binop->op_last = binop->op_first->op_sibling;
79072805 3387
a0d0e21e 3388 return fold_constants((OP *)binop);
79072805
LW		 3389}
3390
5f66b61c
AL		 3391static int uvcompare(const void *a, const void *b)
3392 __attribute__nonnull__(1)
3393 __attribute__nonnull__(2)
3394 __attribute__pure__;
abb2c242 3395static int uvcompare(const void *a, const void *b)
2b9d42f0 3396{
e1ec3a88 3397 if (*((const UV *)a) < (*(const UV *)b))
2b9d42f0 3398 return -1;
e1ec3a88 3399 if (*((const UV *)a) > (*(const UV *)b))
2b9d42f0 3400 return 1;
e1ec3a88 3401 if (*((const UV *)a+1) < (*(const UV *)b+1))
2b9d42f0 3402 return -1;
e1ec3a88 3403 if (*((const UV *)a+1) > (*(const UV *)b+1))
2b9d42f0 3404 return 1;
a0ed51b3
LW		 3405 return 0;
3406}
3407
0d86688d
NC		 3408static OP *
3409S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
79072805 3410{
97aff369 3411 dVAR;
2d03de9c 3412 SV * const tstr = ((SVOP*)expr)->op_sv;
fbbb0949
DM		 3413 SV * const rstr =
3414#ifdef PERL_MAD
3415 (repl->op_type == OP_NULL)
3416 ? ((SVOP*)((LISTOP*)repl)->op_first)->op_sv :
3417#endif
3418 ((SVOP*)repl)->op_sv;
463ee0b2
LW		 3419 STRLEN tlen;
3420 STRLEN rlen;
5c144d81
NC		 3421 const U8 *t = (U8*)SvPV_const(tstr, tlen);
3422 const U8 *r = (U8*)SvPV_const(rstr, rlen);
79072805
LW		 3423 register I32 i;
3424 register I32 j;
9b877dbb 3425 I32 grows = 0;
79072805
LW		 3426 register short *tbl;
3427
551405c4
AL		 3428 const I32 complement = o->op_private & OPpTRANS_COMPLEMENT;
3429 const I32 squash = o->op_private & OPpTRANS_SQUASH;
3430 I32 del = o->op_private & OPpTRANS_DELETE;
043e41b8 3431 SV* swash;
7918f24d
NC		 3432
3433 PERL_ARGS_ASSERT_PMTRANS;
3434
800b4dc4 3435 PL_hints |= HINT_BLOCK_SCOPE;
1c846c1f 3436
036b4402
GS		 3437 if (SvUTF8(tstr))
3438 o->op_private |= OPpTRANS_FROM_UTF;
1c846c1f
NIS		 3439
3440 if (SvUTF8(rstr))
036b4402 3441 o->op_private |= OPpTRANS_TO_UTF;
79072805 3442
a0ed51b3 3443 if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
396482e1 3444 SV* const listsv = newSVpvs("# comment\n");
c445ea15 3445 SV* transv = NULL;
5c144d81
NC		 3446 const U8* tend = t + tlen;
3447 const U8* rend = r + rlen;
ba210ebe 3448 STRLEN ulen;
84c133a0
RB		 3449 UV tfirst = 1;
3450 UV tlast = 0;
3451 IV tdiff;
3452 UV rfirst = 1;
3453 UV rlast = 0;
3454 IV rdiff;
3455 IV diff;
a0ed51b3
LW		 3456 I32 none = 0;
3457 U32 max = 0;
3458 I32 bits;
a0ed51b3 3459 I32 havefinal = 0;
9c5ffd7c 3460 U32 final = 0;
551405c4
AL		 3461 const I32 from_utf = o->op_private & OPpTRANS_FROM_UTF;
3462 const I32 to_utf = o->op_private & OPpTRANS_TO_UTF;
bf4a1e57
JH		 3463 U8* tsave = NULL;
3464 U8* rsave = NULL;
9f7f3913 3465 const U32 flags = UTF8_ALLOW_DEFAULT;
bf4a1e57
JH		 3466
3467 if (!from_utf) {
3468 STRLEN len = tlen;
5c144d81 3469 t = tsave = bytes_to_utf8(t, &len);
bf4a1e57
JH		 3470 tend = t + len;
3471 }
3472 if (!to_utf && rlen) {
3473 STRLEN len = rlen;
5c144d81 3474 r = rsave = bytes_to_utf8(r, &len);
bf4a1e57
JH		 3475 rend = r + len;
3476 }
a0ed51b3 3477
2b9d42f0
NIS		 3478/* There are several snags with this code on EBCDIC:
3479 1. 0xFF is a legal UTF-EBCDIC byte (there are no illegal bytes).
3480 2. scan_const() in toke.c has encoded chars in native encoding which makes
3481 ranges at least in EBCDIC 0..255 range the bottom odd.
3482*/
3483
a0ed51b3 3484 if (complement) {
89ebb4a3 3485 U8 tmpbuf[UTF8_MAXBYTES+1];
2b9d42f0 3486 UV *cp;
a0ed51b3 3487 UV nextmin = 0;
a02a5408 3488 Newx(cp, 2*tlen, UV);
a0ed51b3 3489 i = 0;
396482e1 3490 transv = newSVpvs("");
a0ed51b3 3491 while (t < tend) {
9f7f3913 3492 cp[2*i] = utf8n_to_uvuni(t, tend-t, &ulen, flags);
2b9d42f0
NIS		 3493 t += ulen;
3494 if (t < tend && NATIVE_TO_UTF(*t) == 0xff) {
a0ed51b3 3495 t++;
9f7f3913 3496 cp[2*i+1] = utf8n_to_uvuni(t, tend-t, &ulen, flags);
2b9d42f0 3497 t += ulen;
a0ed51b3 3498 }
2b9d42f0
NIS		 3499 else {
3500 cp[2*i+1] = cp[2*i];
3501 }
3502 i++;
a0ed51b3 3503 }
2b9d42f0 3504 qsort(cp, i, 2*sizeof(UV), uvcompare);
a0ed51b3 3505 for (j = 0; j < i; j++) {
2b9d42f0 3506 UV val = cp[2*j];
a0ed51b3
LW		 3507 diff = val - nextmin;
3508 if (diff > 0) {
9041c2e3 3509 t = uvuni_to_utf8(tmpbuf,nextmin);
dfe13c55 3510 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
a0ed51b3 3511 if (diff > 1) {
2b9d42f0 3512 U8 range_mark = UTF_TO_NATIVE(0xff);
9041c2e3 3513 t = uvuni_to_utf8(tmpbuf, val - 1);
2b9d42f0 3514 sv_catpvn(transv, (char *)&range_mark, 1);
dfe13c55 3515 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
a0ed51b3
LW		 3516 }
3517 }
2b9d42f0 3518 val = cp[2*j+1];
a0ed51b3
LW		 3519 if (val >= nextmin)
3520 nextmin = val + 1;
3521 }
9041c2e3 3522 t = uvuni_to_utf8(tmpbuf,nextmin);
dfe13c55 3523 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
2b9d42f0
NIS		 3524 {
3525 U8 range_mark = UTF_TO_NATIVE(0xff);
3526 sv_catpvn(transv, (char *)&range_mark, 1);
3527 }
b851fbc1
JH		 3528 t = uvuni_to_utf8_flags(tmpbuf, 0x7fffffff,
3529 UNICODE_ALLOW_SUPER);
dfe13c55 3530 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
93524f2b 3531 t = (const U8*)SvPVX_const(transv);
a0ed51b3
LW		 3532 tlen = SvCUR(transv);
3533 tend = t + tlen;
455d824a 3534 Safefree(cp);
a0ed51b3
LW		 3535 }
3536 else if (!rlen && !del) {
3537 r = t; rlen = tlen; rend = tend;
4757a243
LW		 3538 }
3539 if (!squash) {
05d340b8 3540 if ((!rlen && !del) || t == r ||
12ae5dfc 3541 (tlen == rlen && memEQ((char *)t, (char *)r, tlen)))
01ec43d0 3542 {
4757a243 3543 o->op_private |= OPpTRANS_IDENTICAL;
01ec43d0 3544 }
a0ed51b3
LW		 3545 }
3546
3547 while (t < tend || tfirst <= tlast) {
3548 /* see if we need more "t" chars */
3549 if (tfirst > tlast) {
9f7f3913 3550 tfirst = (I32)utf8n_to_uvuni(t, tend - t, &ulen, flags);
a0ed51b3 3551 t += ulen;
2b9d42f0 3552 if (t < tend && NATIVE_TO_UTF(*t) == 0xff) { /* illegal utf8 val indicates range */
ba210ebe 3553 t++;
9f7f3913 3554 tlast = (I32)utf8n_to_uvuni(t, tend - t, &ulen, flags);
a0ed51b3
LW		 3555 t += ulen;
3556 }
3557 else
3558 tlast = tfirst;
3559 }
3560
3561 /* now see if we need more "r" chars */
3562 if (rfirst > rlast) {
3563 if (r < rend) {
9f7f3913 3564 rfirst = (I32)utf8n_to_uvuni(r, rend - r, &ulen, flags);
a0ed51b3 3565 r += ulen;
2b9d42f0 3566 if (r < rend && NATIVE_TO_UTF(*r) == 0xff) { /* illegal utf8 val indicates range */
ba210ebe 3567 r++;
9f7f3913 3568 rlast = (I32)utf8n_to_uvuni(r, rend - r, &ulen, flags);
a0ed51b3
LW		 3569 r += ulen;
3570 }
3571 else
3572 rlast = rfirst;
3573 }
3574 else {
3575 if (!havefinal++)
3576 final = rlast;
3577 rfirst = rlast = 0xffffffff;
3578 }
3579 }
3580
3581 /* now see which range will peter our first, if either. */
3582 tdiff = tlast -