This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Note that STR_WITH_LEN() is unorthodox
[perl5.git] / op.h
CommitLineData
a0d0e21e 1/* op.h
79072805 2 *
1129b882
NC
3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
79072805
LW
5 *
6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
8 *
79072805
LW
9 */
10
11/*
12 * The fields of BASEOP are:
13 * op_next Pointer to next ppcode to execute after this one.
14 * (Top level pre-grafted op points to first op,
15 * but this is replaced when op is grafted in, when
16 * this op will point to the real next op, and the new
17 * parent takes over role of remembering starting op.)
18 * op_ppaddr Pointer to current ppcode's function.
19 * op_type The type of the operation.
2814eb74
PJ
20 * op_opt Whether or not the op has been optimised by the
21 * peephole optimiser.
8be227ab 22 * op_slabbed allocated via opslab
90840c5d
RU
23 * op_static tell op_free() to skip PerlMemShared_free(), when
24 * !op_slabbed.
bb38a9e0 25 * op_savefree on savestack via SAVEFREEOP
3513c740 26 * op_folded Result/remainder of a constant fold operation.
87b5a8b9 27 * op_moresib this op is is not the last sibling
29e61fd9 28 * op_spare One spare bit
79072805
LW
29 * op_flags Flags common to all operations. See OPf_* below.
30 * op_private Flags peculiar to a particular operation (BUT,
31 * by default, set to the number of children until
32 * the operation is privatized by a check routine,
33 * which may or may not check number of children).
34 */
1850c8f9 35#include "op_reg_common.h"
79072805 36
79072805 37#define OPCODE U16
79072805 38
61a59f30 39typedef PERL_BITFIELD16 Optype;
0053d415 40
0f4eea8f
DL
41#ifdef BASEOP_DEFINITION
42#define BASEOP BASEOP_DEFINITION
43#else
79072805
LW
44#define BASEOP \
45 OP* op_next; \
0f9a6232 46 OP* op_sibparent; \
16c91539 47 OP* (*op_ppaddr)(pTHX); \
79072805 48 PADOFFSET op_targ; \
654eccd5
JD
49 PERL_BITFIELD16 op_type:9; \
50 PERL_BITFIELD16 op_opt:1; \
8be227ab 51 PERL_BITFIELD16 op_slabbed:1; \
bb38a9e0 52 PERL_BITFIELD16 op_savefree:1; \
90840c5d 53 PERL_BITFIELD16 op_static:1; \
3513c740 54 PERL_BITFIELD16 op_folded:1; \
87b5a8b9 55 PERL_BITFIELD16 op_moresib:1; \
29e61fd9 56 PERL_BITFIELD16 op_spare:1; \
a0d0e21e
LW
57 U8 op_flags; \
58 U8 op_private;
0f4eea8f 59#endif
79072805 60
13febba5 61/* If op_type:9 is changed to :10, also change cx_pusheval()
0053d415
JD
62 Also, if the type of op_type is ever changed (e.g. to PERL_BITFIELD32)
63 then all the other bit-fields before/after it should change their
64 types too to let VC pack them into the same 4 byte integer.*/
17347a51 65
fe615074 66/* for efficiency, requires OPf_WANT_VOID == G_VOID etc */
54310121 67#define OP_GIMME(op,dfl) \
fe615074 68 (((op)->op_flags & OPf_WANT) ? ((op)->op_flags & OPf_WANT) : dfl)
54310121 69
2f8edad0 70#define OP_GIMME_REVERSE(flags) ((flags) & G_WANT)
4f911530 71
954c1994 72/*
ccfc67b7
JH
73=head1 "Gimme" Values
74
954c1994
GS
75=for apidoc Amn|U32|GIMME_V
76The XSUB-writer's equivalent to Perl's C<wantarray>. Returns C<G_VOID>,
91e74348 77C<G_SCALAR> or C<G_ARRAY> for void, scalar or list context,
72d33970 78respectively. See L<perlcall> for a usage example.
954c1994
GS
79
80=for apidoc Amn|U32|GIMME
81A backward-compatible version of C<GIMME_V> which can only return
82C<G_SCALAR> or C<G_ARRAY>; in a void context, it returns C<G_SCALAR>.
83Deprecated. Use C<GIMME_V> instead.
84
85=cut
86*/
87
533c011a 88#define GIMME_V OP_GIMME(PL_op, block_gimme())
79072805
LW
89
90/* Public flags */
54310121
PP
91
92#define OPf_WANT 3 /* Mask for "want" bits: */
93#define OPf_WANT_VOID 1 /* Want nothing */
94#define OPf_WANT_SCALAR 2 /* Want single value */
95#define OPf_WANT_LIST 3 /* Want list of any length */
79072805
LW
96#define OPf_KIDS 4 /* There is a firstborn child. */
97#define OPf_PARENS 8 /* This operator was parenthesized. */
463ee0b2 98 /* (Or block needs explicit scope entry.) */
a0d0e21e
LW
99#define OPf_REF 16 /* Certified reference. */
100 /* (Return container, not containee). */
101#define OPf_MOD 32 /* Will modify (lvalue). */
72876cce 102
a0d0e21e 103#define OPf_STACKED 64 /* Some arg is arriving on the stack. */
72876cce
DM
104 /* Indicates mutator-variant of op for those
105 * ops which support them, e.g. $x += 1
106 */
107
79072805
LW
108#define OPf_SPECIAL 128 /* Do something weird for this op: */
109 /* On local LVAL, don't init local value. */
110 /* On OP_SORT, subroutine is inlined. */
111 /* On OP_NOT, inversion was implicit. */
c349b9a0
DM
112 /* On OP_LEAVE, don't restore curpm, e.g.
113 * /(...)/ while ...>; */
79072805
LW
114 /* On truncate, we truncate filehandle */
115 /* On control verbs, we saw no label */
116 /* On flipflop, we saw ... instead of .. */
117 /* On UNOPs, saw bare parens, e.g. eof(). */
deb92a6c 118 /* On OP_CHDIR, handle (or bare parens) */
a2167ea9 119 /* On OP_NULL, saw a "do". */
afebc493 120 /* On OP_EXISTS, treat av as av, not avhv. */
f2ec2afd 121 /* On OP_(ENTER|LEAVE)EVAL, don't clear $@ */
497711e7 122 /* On regcomp, "use re 'eval'" was in scope */
17fda545
NC
123 /* On RV2[ACGHS]V, don't create GV--in
124 defined()*/
5df8de69
DM
125 /* On OP_DBSTATE, indicates breakpoint
126 * (runtime property) */
6b514a0d 127 /* On OP_REQUIRE, was seen as CORE::require */
7896dde7
Z
128 /* On OP_(ENTER|LEAVE)WHEN, there's
129 no condition */
130 /* On OP_SMARTMATCH, an implicit smartmatch */
78c72037
NC
131 /* On OP_ANONHASH and OP_ANONLIST, create a
132 reference to the new anon hash or array */
fedf30e1
DM
133 /* On OP_HELEM, OP_MULTIDEREF and OP_HSLICE,
134 localization will be followed by assignment,
135 so do not wipe the target if it is special
136 (e.g. a glob or a magic SV) */
2474a784
FC
137 /* On OP_MATCH, OP_SUBST & OP_TRANS, the
138 operand of a logical or conditional
139 that was optimised away, so it should
140 not be bound via =~ */
6b7c6d95 141 /* On OP_CONST, from a constant CV */
d67594ff
FC
142 /* On OP_GLOB, two meanings:
143 - Before ck_glob, called as CORE::glob
144 - After ck_glob, use Perl glob function
145 */
d5524600 146 /* On OP_PADRANGE, push @_ */
7d1d69cb 147 /* On OP_DUMP, has no label */
205681b5 148 /* On OP_UNSTACK, in a C-style for loop */
6d4eed21
FC
149/* There is no room in op_flags for this one, so it has its own bit-
150 field member (op_folded) instead. The flag is only used to tell
151 op_convert_list to set op_folded. */
faab18b6 152#define OPf_FOLDED (1<<16)
79072805 153
54310121 154/* old names; don't use in new code, but don't break them, either */
d91ab173
GS
155#define OPf_LIST OPf_WANT_LIST
156#define OPf_KNOW OPf_WANT
954c1994 157
7143f21c 158#if !defined(PERL_CORE) && !defined(PERL_EXT)
82334630 159# define GIMME \
62a559b8
NIS
160 (PL_op->op_flags & OPf_WANT \
161 ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST \
d91ab173
GS
162 ? G_ARRAY \
163 : G_SCALAR) \
164 : dowantarray())
82334630 165#endif
54310121 166
1dafeec8 167
f3574cc6
DM
168/* NOTE: OPp* flags are now auto-generated and defined in opcode.h,
169 * from data in regen/op_private */
d41ff1b8 170
a0d0e21e 171
59f00321 172#define OPpTRANS_ALL (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF|OPpTRANS_IDENTICAL|OPpTRANS_SQUASH|OPpTRANS_COMPLEMENT|OPpTRANS_GROWS|OPpTRANS_DELETE)
79072805 173
97e1065a 174
97e1065a 175
f3574cc6
DM
176/* Mask for OP_ENTERSUB flags, the absence of which must be propagated
177 in dynamic context */
777d9014
FC
178#define OPpENTERSUB_LVAL_MASK (OPpLVAL_INTRO|OPpENTERSUB_INARGS)
179
5db1eb8d 180
2f7c6295
DM
181/* things that can be elements of op_aux */
182typedef union {
183 PADOFFSET pad_offset;
184 SV *sv;
185 IV iv;
186 UV uv;
e839e6ed 187 char *pv;
b5bf9f73 188 SSize_t ssize;
2f7c6295
DM
189} UNOP_AUX_item;
190
fedf30e1
DM
191#ifdef USE_ITHREADS
192# define UNOP_AUX_item_sv(item) PAD_SVl((item)->pad_offset);
193#else
194# define UNOP_AUX_item_sv(item) ((item)->sv);
195#endif
196
197
198
60041a09 199
79072805
LW
200struct op {
201 BASEOP
202};
203
204struct unop {
205 BASEOP
206 OP * op_first;
207};
208
2f7c6295
DM
209struct unop_aux {
210 BASEOP
211 OP *op_first;
212 UNOP_AUX_item *op_aux;
213};
214
79072805
LW
215struct binop {
216 BASEOP
217 OP * op_first;
218 OP * op_last;
219};
220
221struct logop {
222 BASEOP
223 OP * op_first;
224 OP * op_other;
225};
226
79072805
LW
227struct listop {
228 BASEOP
229 OP * op_first;
230 OP * op_last;
79072805
LW
231};
232
b46e009d 233struct methop {
234 BASEOP
235 union {
236 /* op_u.op_first *must* be aligned the same as the op_first
237 * field of the other op types, and op_u.op_meth_sv *must*
238 * be aligned with op_sv */
239 OP* op_first; /* optree for method name */
240 SV* op_meth_sv; /* static method name */
241 } op_u;
810bd8b7 242#ifdef USE_ITHREADS
243 PADOFFSET op_rclass_targ; /* pad index for redirect class */
244#else
245 SV* op_rclass_sv; /* static redirect class $o->A::meth() */
246#endif
b46e009d 247};
248
79072805
LW
249struct pmop {
250 BASEOP
251 OP * op_first;
252 OP * op_last;
1fcf4c12 253#ifdef USE_ITHREADS
784e50c8 254 PADOFFSET op_pmoffset;
1fcf4c12
AB
255#else
256 REGEXP * op_pmregexp; /* compiled expression */
257#endif
69bdead3 258 U32 op_pmflags;
29f2e912 259 union {
20e98b0f 260 OP * op_pmreplroot; /* For OP_SUBST */
5012eebe
DM
261 PADOFFSET op_pmtargetoff; /* For OP_SPLIT lex ary or thr GV */
262 GV * op_pmtargetgv; /* For OP_SPLIT non-threaded GV */
20e98b0f
NC
263 } op_pmreplrootu;
264 union {
29f2e912 265 OP * op_pmreplstart; /* Only used in OP_SUBST */
cb55de95 266#ifdef USE_ITHREADS
23083432 267 PADOFFSET op_pmstashoff; /* Only used in OP_MATCH, with PMf_ONCE set */
cb55de95 268#else
29f2e912 269 HV * op_pmstash;
cb55de95 270#endif
29f2e912 271 } op_pmstashstartu;
68e2671b 272 OP * op_code_list; /* list of (?{}) code blocks */
79072805 273};
a0d0e21e 274
1fcf4c12 275#ifdef USE_ITHREADS
14a49a24
NC
276#define PM_GETRE(o) (SvTYPE(PL_regex_pad[(o)->op_pmoffset]) == SVt_REGEXP \
277 ? (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) : NULL)
ede1273d
NC
278/* The assignment is just to enforce type safety (or at least get a warning).
279 */
14a49a24
NC
280/* With first class regexps not via a reference one needs to assign
281 &PL_sv_undef under ithreads. (This would probably work unthreaded, but NULL
282 is cheaper. I guess we could allow NULL, but the check above would get
283 more complex, and we'd have an AV with (SV*)NULL in it, which feels bad */
284/* BEWARE - something that calls this macro passes (r) which has a side
285 effect. */
ede1273d 286#define PM_SETRE(o,r) STMT_START { \
b1bc3f34 287 REGEXP *const _pm_setre = (r); \
7948fc08 288 assert(_pm_setre); \
b1bc3f34 289 PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(_pm_setre); \
ede1273d 290 } STMT_END
1fcf4c12 291#else
b9ed2502
AB
292#define PM_GETRE(o) ((o)->op_pmregexp)
293#define PM_SETRE(o,r) ((o)->op_pmregexp = (r))
1fcf4c12 294#endif
4825b64b 295
a6cd0fea
KW
296/* Currently these PMf flags occupy a single 32-bit word. Not all bits are
297 * currently used. The lower bits are shared with their corresponding RXf flag
298 * bits, up to but not including _RXf_PMf_SHIFT_NEXT. The unused bits
299 * immediately follow; finally the used Pmf-only (unshared) bits, so that the
300 * highest bit in the word is used. This gathers all the unused bits as a pool
301 * in the middle, like so: 11111111111111110000001111111111
302 * where the '1's represent used bits, and the '0's unused. This design allows
303 * us to allocate off one end of the pool if we need to add a shared bit, and
304 * off the other end if we need a non-shared bit, without disturbing the other
305 * bits. This maximizes the likelihood of being able to change things without
306 * breaking binary compatibility.
307 *
308 * To add shared bits, do so in op_reg_common.h. This should change
309 * _RXf_PMf_SHIFT_NEXT so that things won't compile. Then come to regexp.h and
310 * op.h and adjust the constant adders in the definitions of PMf_BASE_SHIFT and
311 * Pmf_BASE_SHIFT down by the number of shared bits you added. That's it.
312 * Things should be binary compatible. But if either of these gets to having
313 * to subtract rather than add, leave at 0 and adjust all the entries below
314 * that are in terms of this according. But if the first one of those is
315 * already PMf_BASE_SHIFT+0, there are no bits left, and a redesign is in
316 * order.
317 *
318 * To remove unshared bits, just delete its entry. If you're where breaking
319 * binary compatibility is ok to do, you might want to adjust things to move
320 * the newly opened space so that it gets absorbed into the common pool.
321 *
322 * To add unshared bits, first use up any gaps in the middle. Otherwise,
323 * allocate off the low end until you get to PMf_BASE_SHIFT+0. If that isn't
324 * enough, move PMf_BASE_SHIFT down (if possible) and add the new bit at the
325 * other end instead; this preserves binary compatibility. */
d262c0c7 326#define PMf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+2)
f4a4cecb 327
7c449856
KW
328/* Set by the parser if it discovers an error, so the regex shouldn't be
329 * compiled */
330#define PMf_HAS_ERROR (1U<<(PMf_BASE_SHIFT+4))
331
ef07e810 332/* 'use re "taint"' in scope: taint $1 etc. if target tainted */
9cba692b 333#define PMf_RETAINT (1U<<(PMf_BASE_SHIFT+5))
c737faaf 334
c0f1c194
KW
335/* match successfully only once per reset, with related flag RXf_USED in
336 * re->extflags holding state. This is used only for ?? matches, and only on
337 * OP_MATCH and OP_QR */
9cba692b 338#define PMf_ONCE (1U<<(PMf_BASE_SHIFT+6))
1850c8f9 339
d234778b 340/* PMf_ONCE, i.e. ?pat?, has matched successfully. Not used under threading. */
9cba692b 341#define PMf_USED (1U<<(PMf_BASE_SHIFT+7))
1850c8f9
KW
342
343/* subst replacement is constant */
9cba692b 344#define PMf_CONST (1U<<(PMf_BASE_SHIFT+8))
c737faaf 345
1850c8f9 346/* keep 1st runtime pattern forever */
9cba692b 347#define PMf_KEEP (1U<<(PMf_BASE_SHIFT+9))
4da3eb8b 348
9cba692b 349#define PMf_GLOBAL (1U<<(PMf_BASE_SHIFT+10)) /* pattern had a g modifier */
c737faaf 350
1850c8f9 351/* don't reset pos() if //g fails */
9cba692b 352#define PMf_CONTINUE (1U<<(PMf_BASE_SHIFT+11))
1850c8f9
KW
353
354/* evaluating replacement as expr */
9cba692b 355#define PMf_EVAL (1U<<(PMf_BASE_SHIFT+12))
c0f1c194
KW
356
357/* Return substituted string instead of modifying it. */
9cba692b 358#define PMf_NONDESTRUCT (1U<<(PMf_BASE_SHIFT+13))
e357fc67 359
d63c20f2 360/* the pattern has a CV attached (currently only under qr/...(?{}).../) */
9cba692b 361#define PMf_HAS_CV (1U<<(PMf_BASE_SHIFT+14))
d63c20f2 362
867940b8
DM
363/* op_code_list is private; don't free it etc. It may well point to
364 * code within another sub, with different pad etc */
9cba692b 365#define PMf_CODELIST_PRIVATE (1U<<(PMf_BASE_SHIFT+15))
867940b8 366
2a92a973
DM
367/* the PMOP is a QR (we should be able to detect that from the op type,
368 * but the regex compilation API passes just the pm flags, not the op
369 * itself */
9cba692b
KW
370#define PMf_IS_QR (1U<<(PMf_BASE_SHIFT+16))
371#define PMf_USE_RE_EVAL (1U<<(PMf_BASE_SHIFT+17)) /* use re'eval' in scope */
a6cd0fea
KW
372
373/* See comments at the beginning of these defines about adding bits. The
374 * highest bit position should be used, so that if PMf_BASE_SHIFT gets
375 * increased, the #error below will be triggered so that you will be reminded
376 * to adjust things at the other end to keep the bit positions unchanged */
377#if PMf_BASE_SHIFT+17 > 31
32cdcf9d 378# error Too many PMf_ bits used. See above and regnodes.h for any spare in middle
1850c8f9 379#endif
79072805 380
cb55de95 381#ifdef USE_ITHREADS
05ec9bb3 382
23083432
FC
383# define PmopSTASH(o) ((o)->op_pmflags & PMf_ONCE \
384 ? PL_stashpad[(o)->op_pmstashstartu.op_pmstashoff] \
385 : NULL)
386# define PmopSTASH_set(o,hv) \
387 (assert_((o)->op_pmflags & PMf_ONCE) \
388 (o)->op_pmstashstartu.op_pmstashoff = \
01f44973 389 (hv) ? alloccopstash(hv) : 0)
cb55de95 390#else
29f2e912
NC
391# define PmopSTASH(o) \
392 (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstash : NULL)
393# if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
394# define PmopSTASH_set(o,hv) ({ \
395 assert((o)->op_pmflags & PMf_ONCE); \
396 ((o)->op_pmstashstartu.op_pmstash = (hv)); \
397 })
398# else
399# define PmopSTASH_set(o,hv) ((o)->op_pmstashstartu.op_pmstash = (hv))
400# endif
cb55de95 401#endif
23083432
FC
402#define PmopSTASHPV(o) (PmopSTASH(o) ? HvNAME_get(PmopSTASH(o)) : NULL)
403 /* op_pmstashstartu.op_pmstash is not refcounted */
404#define PmopSTASHPV_set(o,pv) PmopSTASH_set((o), gv_stashpv(pv,GV_ADD))
cb55de95 405
79072805
LW
406struct svop {
407 BASEOP
408 SV * op_sv;
409};
410
7934575e 411struct padop {
79072805 412 BASEOP
7934575e 413 PADOFFSET op_padix;
79072805
LW
414};
415
416struct pvop {
417 BASEOP
418 char * op_pv;
419};
420
79072805
LW
421struct loop {
422 BASEOP
423 OP * op_first;
424 OP * op_last;
79072805
LW
425 OP * op_redoop;
426 OP * op_nextop;
427 OP * op_lastop;
428};
429
9524b6e6
FC
430#define cUNOPx(o) ((UNOP*)(o))
431#define cUNOP_AUXx(o) ((UNOP_AUX*)(o))
432#define cBINOPx(o) ((BINOP*)(o))
433#define cLISTOPx(o) ((LISTOP*)(o))
434#define cLOGOPx(o) ((LOGOP*)(o))
435#define cPMOPx(o) ((PMOP*)(o))
436#define cSVOPx(o) ((SVOP*)(o))
437#define cPADOPx(o) ((PADOP*)(o))
438#define cPVOPx(o) ((PVOP*)(o))
439#define cCOPx(o) ((COP*)(o))
440#define cLOOPx(o) ((LOOP*)(o))
441#define cMETHOPx(o) ((METHOP*)(o))
350de78d
GS
442
443#define cUNOP cUNOPx(PL_op)
2f7c6295 444#define cUNOP_AUX cUNOP_AUXx(PL_op)
350de78d
GS
445#define cBINOP cBINOPx(PL_op)
446#define cLISTOP cLISTOPx(PL_op)
447#define cLOGOP cLOGOPx(PL_op)
448#define cPMOP cPMOPx(PL_op)
449#define cSVOP cSVOPx(PL_op)
450#define cPADOP cPADOPx(PL_op)
451#define cPVOP cPVOPx(PL_op)
452#define cCOP cCOPx(PL_op)
453#define cLOOP cLOOPx(PL_op)
454
455#define cUNOPo cUNOPx(o)
2f7c6295 456#define cUNOP_AUXo cUNOP_AUXx(o)
350de78d
GS
457#define cBINOPo cBINOPx(o)
458#define cLISTOPo cLISTOPx(o)
459#define cLOGOPo cLOGOPx(o)
460#define cPMOPo cPMOPx(o)
461#define cSVOPo cSVOPx(o)
462#define cPADOPo cPADOPx(o)
463#define cPVOPo cPVOPx(o)
464#define cCOPo cCOPx(o)
465#define cLOOPo cLOOPx(o)
466
467#define kUNOP cUNOPx(kid)
2f7c6295 468#define kUNOP_AUX cUNOP_AUXx(kid)
350de78d
GS
469#define kBINOP cBINOPx(kid)
470#define kLISTOP cLISTOPx(kid)
471#define kLOGOP cLOGOPx(kid)
472#define kPMOP cPMOPx(kid)
473#define kSVOP cSVOPx(kid)
474#define kPADOP cPADOPx(kid)
475#define kPVOP cPVOPx(kid)
476#define kCOP cCOPx(kid)
477#define kLOOP cLOOPx(kid)
478
479
1e85b658
DM
480typedef enum {
481 OPclass_NULL, /* 0 */
482 OPclass_BASEOP, /* 1 */
483 OPclass_UNOP, /* 2 */
484 OPclass_BINOP, /* 3 */
485 OPclass_LOGOP, /* 4 */
486 OPclass_LISTOP, /* 5 */
487 OPclass_PMOP, /* 6 */
488 OPclass_SVOP, /* 7 */
489 OPclass_PADOP, /* 8 */
490 OPclass_PVOP, /* 9 */
491 OPclass_LOOP, /* 10 */
492 OPclass_COP, /* 11 */
493 OPclass_METHOP, /* 12 */
494 OPclass_UNOP_AUX /* 13 */
495} OPclass;
496
497
350de78d 498#ifdef USE_ITHREADS
dd2155a4 499# define cGVOPx_gv(o) ((GV*)PAD_SVl(cPADOPx(o)->op_padix))
9429039d
FC
500# ifndef PERL_CORE
501# define IS_PADGV(v) (v && isGV(v))
502# define IS_PADCONST(v) \
f5a0fd1e 503 (v && (SvREADONLY(v) || (SvIsCOW(v) && !SvLEN(v))))
9429039d 504# endif
7766f137 505# define cSVOPx_sv(v) (cSVOPx(v)->op_sv \
dd2155a4 506 ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ))
638eceb6 507# define cSVOPx_svp(v) (cSVOPx(v)->op_sv \
dd2155a4 508 ? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ))
810bd8b7 509# define cMETHOPx_rclass(v) PAD_SVl(cMETHOPx(v)->op_rclass_targ)
350de78d 510#else
638eceb6 511# define cGVOPx_gv(o) ((GV*)cSVOPx(o)->op_sv)
9429039d
FC
512# ifndef PERL_CORE
513# define IS_PADGV(v) FALSE
514# define IS_PADCONST(v) FALSE
515# endif
7766f137 516# define cSVOPx_sv(v) (cSVOPx(v)->op_sv)
638eceb6 517# define cSVOPx_svp(v) (&cSVOPx(v)->op_sv)
810bd8b7 518# define cMETHOPx_rclass(v) (cMETHOPx(v)->op_rclass_sv)
350de78d 519#endif
79072805 520
f88ca576 521#define cMETHOPx_meth(v) cSVOPx_sv(v)
b46e009d 522
638eceb6
GS
523#define cGVOP_gv cGVOPx_gv(PL_op)
524#define cGVOPo_gv cGVOPx_gv(o)
525#define kGVOP_gv cGVOPx_gv(kid)
526#define cSVOP_sv cSVOPx_sv(PL_op)
527#define cSVOPo_sv cSVOPx_sv(o)
528#define kSVOP_sv cSVOPx_sv(kid)
7766f137 529
bcabcc50
NC
530#ifndef PERL_CORE
531# define Nullop ((OP*)NULL)
532#endif
79072805 533
cee4176c 534/* Lowest byte of PL_opargs */
a0d0e21e
LW
535#define OA_MARK 1
536#define OA_FOLDCONST 2
537#define OA_RETSCALAR 4
538#define OA_TARGET 8
903fd87c 539#define OA_TARGLEX 16
a0d0e21e
LW
540#define OA_OTHERINT 32
541#define OA_DANGEROUS 64
542#define OA_DEFGV 128
543
738ec380 544/* The next 4 bits (8..11) encode op class information */
903fd87c 545#define OCSHIFT 8
b162f9ea
IZ
546
547#define OA_CLASS_MASK (15 << OCSHIFT)
548
549#define OA_BASEOP (0 << OCSHIFT)
550#define OA_UNOP (1 << OCSHIFT)
551#define OA_BINOP (2 << OCSHIFT)
552#define OA_LOGOP (3 << OCSHIFT)
1a67a97c
SM
553#define OA_LISTOP (4 << OCSHIFT)
554#define OA_PMOP (5 << OCSHIFT)
555#define OA_SVOP (6 << OCSHIFT)
7934575e 556#define OA_PADOP (7 << OCSHIFT)
1a67a97c
SM
557#define OA_PVOP_OR_SVOP (8 << OCSHIFT)
558#define OA_LOOP (9 << OCSHIFT)
559#define OA_COP (10 << OCSHIFT)
560#define OA_BASEOP_OR_UNOP (11 << OCSHIFT)
561#define OA_FILESTATOP (12 << OCSHIFT)
562#define OA_LOOPEXOP (13 << OCSHIFT)
b46e009d 563#define OA_METHOP (14 << OCSHIFT)
2f7c6295 564#define OA_UNOP_AUX (15 << OCSHIFT)
b162f9ea 565
738ec380
DM
566/* Each remaining nybble of PL_opargs (i.e. bits 12..15, 16..19 etc)
567 * encode the type for each arg */
903fd87c 568#define OASHIFT 12
a0d0e21e 569
a0d0e21e
LW
570#define OA_SCALAR 1
571#define OA_LIST 2
572#define OA_AVREF 3
573#define OA_HVREF 4
574#define OA_CVREF 5
575#define OA_FILEREF 6
576#define OA_SCALARREF 7
577#define OA_OPTIONAL 8
578
d3c72c2a
DM
579/* Op_REFCNT is a reference count at the head of each op tree: needed
580 * since the tree is shared between threads, and between cloned closure
581 * copies in the same thread. OP_REFCNT_LOCK/UNLOCK is used when modifying
582 * this count.
583 * The same mutex is used to protect the refcounts of the reg_trie_data
584 * and reg_ac_data structures, which are shared between duplicated
585 * regexes.
586 */
587
534825c4
GS
588#ifdef USE_ITHREADS
589# define OP_REFCNT_INIT MUTEX_INIT(&PL_op_mutex)
4026c95a
SH
590# ifdef PERL_CORE
591# define OP_REFCNT_LOCK MUTEX_LOCK(&PL_op_mutex)
592# define OP_REFCNT_UNLOCK MUTEX_UNLOCK(&PL_op_mutex)
593# else
594# define OP_REFCNT_LOCK op_refcnt_lock()
595# define OP_REFCNT_UNLOCK op_refcnt_unlock()
596# endif
534825c4 597# define OP_REFCNT_TERM MUTEX_DESTROY(&PL_op_mutex)
534825c4
GS
598#else
599# define OP_REFCNT_INIT NOOP
600# define OP_REFCNT_LOCK NOOP
601# define OP_REFCNT_UNLOCK NOOP
602# define OP_REFCNT_TERM NOOP
534825c4 603#endif
e4783991 604
282f25c9 605#define OpREFCNT_set(o,n) ((o)->op_targ = (n))
fc97af9c
NC
606#ifdef PERL_DEBUG_READONLY_OPS
607# define OpREFCNT_inc(o) Perl_op_refcnt_inc(aTHX_ o)
608# define OpREFCNT_dec(o) Perl_op_refcnt_dec(aTHX_ o)
609#else
610# define OpREFCNT_inc(o) ((o) ? (++(o)->op_targ, (o)) : NULL)
611# define OpREFCNT_dec(o) (--(o)->op_targ)
612#endif
282f25c9 613
e4783991 614/* flags used by Perl_load_module() */
ec6d81ab
RGS
615#define PERL_LOADMOD_DENY 0x1 /* no Module */
616#define PERL_LOADMOD_NOIMPORT 0x2 /* use Module () */
466f50cc
FC
617#define PERL_LOADMOD_IMPORT_OPS 0x4 /* import arguments
618 are passed as a sin-
619 gle op tree, not a
620 list of SVs */
e5dd39fc 621
30d9c59b 622#if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C)
e4c5ccf3 623#define ref(o, type) doref(o, type, TRUE)
a0c21aa1 624#endif
e4c5ccf3 625
c1048fcf 626
0b9a13c3 627/* translation table attached to OP_TRANS/OP_TRANSR ops */
c1048fcf
DM
628
629typedef struct {
0b9a13c3
DM
630 Size_t size; /* number of entries in map[], not including final slot */
631 short map[1]; /* Unwarranted chumminess */
c1048fcf
DM
632} OPtrans_map;
633
c1048fcf 634
5983a79d
BM
635/*
636=head1 Optree Manipulation Functions
637
638=for apidoc Am|OP*|LINKLIST|OP *o
639Given the root of an optree, link the tree in execution order using the
72d33970 640C<op_next> pointers and return the first op executed. If this has
5983a79d 641already been done, it will not be redone, and C<< o->op_next >> will be
2d7f6611 642returned. If C<< o->op_next >> is not already set, C<o> should be at
5983a79d
BM
643least an C<UNOP>.
644
645=cut
646*/
647
648#define LINKLIST(o) ((o)->op_next ? (o)->op_next : op_linklist((OP*)o))
649
33f36c71
NC
650/* no longer used anywhere in core */
651#ifndef PERL_CORE
46471bde 652#define cv_ckproto(cv, gv, p) \
f717afa7 653 cv_ckproto_len_flags((cv), (gv), (p), (p) ? strlen(p) : 0, 0)
33f36c71
NC
654#endif
655
7d0905b9
NC
656#ifdef PERL_CORE
657# define my(o) my_attrs((o), NULL)
658#endif
659
e5dd39fc 660#ifdef USE_REENTRANT_API
10bc17b6 661#include "reentr.h"
e5dd39fc
AB
662#endif
663
c7e45529 664#define NewOp(m,var,c,type) \
e91d68d5 665 (var = (type *) Perl_Slab_Alloc(aTHX_ c*sizeof(type)))
c7e45529 666#define NewOpSz(m,var,size) \
e91d68d5 667 (var = (OP *) Perl_Slab_Alloc(aTHX_ size))
c7e45529 668#define FreeOp(p) Perl_Slab_Free(aTHX_ p)
8be227ab
FC
669
670/*
671 * The per-CV op slabs consist of a header (the opslab struct) and a bunch
672 * of space for allocating op slots, each of which consists of two pointers
673 * followed by an op. The first pointer points to the next op slot. The
674 * second points to the slab. At the end of the slab is a null pointer,
675 * so that slot->opslot_next - slot can be used to determine the size
676 * of the op.
677 *
678 * Each CV can have multiple slabs; opslab_next points to the next slab, to
679 * form a chain. All bookkeeping is done on the first slab, which is where
680 * all the op slots point.
681 *
682 * Freed ops are marked as freed and attached to the freed chain
683 * via op_next pointers.
684 *
685 * When there is more than one slab, the second slab in the slab chain is
686 * assumed to be the one with free space available. It is used when allo-
687 * cating an op if there are no freed ops available or big enough.
688 */
689
7aef8e5b 690#ifdef PERL_CORE
8be227ab 691struct opslot {
8c47b5bc 692 U16 opslot_size; /* size of this slot (in pointers) */
17b8f3a1 693 U16 opslot_offset; /* offset from start of slab (in ptr units) */
8be227ab
FC
694 OP opslot_op; /* the op itself */
695};
696
697struct opslab {
8be227ab 698 OPSLAB * opslab_next; /* next slab */
17b8f3a1 699 OPSLAB * opslab_head; /* first slab in chain */
c63fff64 700 OP * opslab_freed; /* chain of freed ops (head only)*/
17b8f3a1 701 size_t opslab_refcnt; /* number of ops (head slab only) */
aa034fa0
DM
702 U16 opslab_size; /* size of slab in pointers,
703 including header */
7b85c12a
DM
704 U16 opslab_free_space; /* space available in this slab
705 for allocating new ops (in ptr
706 units) */
3107b51f 707# ifdef PERL_DEBUG_READONLY_OPS
3107b51f
FC
708 bool opslab_readonly;
709# endif
8be227ab
FC
710 OPSLOT opslab_slots; /* slots begin here */
711};
712
713# define OPSLOT_HEADER STRUCT_OFFSET(OPSLOT, opslot_op)
714# define OPSLOT_HEADER_P (OPSLOT_HEADER/sizeof(I32 *))
c7724415 715# define OpSLOT(o) (assert_(o->op_slabbed) \
8be227ab 716 (OPSLOT *)(((char *)o)-OPSLOT_HEADER))
17b8f3a1
DM
717
718/* the first (head) opslab of the chain in which this op is allocated */
719# define OpSLAB(o) \
720 (((OPSLAB*)( (I32**)OpSLOT(o) - OpSLOT(o)->opslot_offset))->opslab_head)
721
8be227ab
FC
722# define OpslabREFCNT_dec(slab) \
723 (((slab)->opslab_refcnt == 1) \
724 ? opslab_free_nopad(slab) \
725 : (void)--(slab)->opslab_refcnt)
726 /* Variant that does not null out the pads */
727# define OpslabREFCNT_dec_padok(slab) \
728 (((slab)->opslab_refcnt == 1) \
729 ? opslab_free(slab) \
730 : (void)--(slab)->opslab_refcnt)
c7e45529 731#endif
598921a7 732
1930840b 733struct block_hooks {
52db365a 734 U32 bhk_flags;
1930840b
BM
735 void (*bhk_start) (pTHX_ int full);
736 void (*bhk_pre_end) (pTHX_ OP **seq);
737 void (*bhk_post_end) (pTHX_ OP **seq);
52db365a 738 void (*bhk_eval) (pTHX_ OP *const saveop);
1930840b
BM
739};
740
fd85fad2
BM
741/*
742=head1 Compile-time scope hooks
743
3e4ddde5 744=for apidoc mx|U32|BhkFLAGS|BHK *hk
fd85fad2
BM
745Return the BHK's flags.
746
3e4ddde5 747=for apidoc mx|void *|BhkENTRY|BHK *hk|which
2d7f6611 748Return an entry from the BHK structure. C<which> is a preprocessor token
72d33970 749indicating which entry to return. If the appropriate flag is not set
796b6530 750this will return C<NULL>. The type of the return value depends on which
fd85fad2
BM
751entry you ask for.
752
3e4ddde5 753=for apidoc Amx|void|BhkENTRY_set|BHK *hk|which|void *ptr
fd85fad2 754Set an entry in the BHK structure, and set the flags to indicate it is
2d7f6611
KW
755valid. C<which> is a preprocessing token indicating which entry to set.
756The type of C<ptr> depends on the entry.
fd85fad2 757
3e4ddde5 758=for apidoc Amx|void|BhkDISABLE|BHK *hk|which
a3e07c87 759Temporarily disable an entry in this BHK structure, by clearing the
2d7f6611 760appropriate flag. C<which> is a preprocessor token indicating which
a3e07c87
BM
761entry to disable.
762
3e4ddde5 763=for apidoc Amx|void|BhkENABLE|BHK *hk|which
a3e07c87 764Re-enable an entry in this BHK structure, by setting the appropriate
2d7f6611 765flag. C<which> is a preprocessor token indicating which entry to enable.
a3e07c87
BM
766This will assert (under -DDEBUGGING) if the entry doesn't contain a valid
767pointer.
768
3e4ddde5 769=for apidoc mx|void|CALL_BLOCK_HOOKS|which|arg
2d7f6611
KW
770Call all the registered block hooks for type C<which>. C<which> is a
771preprocessing token; the type of C<arg> depends on C<which>.
fd85fad2
BM
772
773=cut
774*/
775
52db365a
BM
776#define BhkFLAGS(hk) ((hk)->bhk_flags)
777
a88d97bf
BM
778#define BHKf_bhk_start 0x01
779#define BHKf_bhk_pre_end 0x02
780#define BHKf_bhk_post_end 0x04
781#define BHKf_bhk_eval 0x08
52db365a
BM
782
783#define BhkENTRY(hk, which) \
a88d97bf 784 ((BhkFLAGS(hk) & BHKf_ ## which) ? ((hk)->which) : NULL)
52db365a 785
a3e07c87
BM
786#define BhkENABLE(hk, which) \
787 STMT_START { \
788 BhkFLAGS(hk) |= BHKf_ ## which; \
789 assert(BhkENTRY(hk, which)); \
790 } STMT_END
791
792#define BhkDISABLE(hk, which) \
793 STMT_START { \
794 BhkFLAGS(hk) &= ~(BHKf_ ## which); \
795 } STMT_END
796
52db365a
BM
797#define BhkENTRY_set(hk, which, ptr) \
798 STMT_START { \
a88d97bf 799 (hk)->which = ptr; \
a3e07c87 800 BhkENABLE(hk, which); \
52db365a
BM
801 } STMT_END
802
1930840b
BM
803#define CALL_BLOCK_HOOKS(which, arg) \
804 STMT_START { \
805 if (PL_blockhooks) { \
c70927a6 806 SSize_t i; \
b9f2b683 807 for (i = av_tindex(PL_blockhooks); i >= 0; i--) { \
1930840b 808 SV *sv = AvARRAY(PL_blockhooks)[i]; \
52db365a 809 BHK *hk; \
1930840b
BM
810 \
811 assert(SvIOK(sv)); \
812 if (SvUOK(sv)) \
52db365a 813 hk = INT2PTR(BHK *, SvUVX(sv)); \
1930840b 814 else \
52db365a 815 hk = INT2PTR(BHK *, SvIVX(sv)); \
1930840b 816 \
52db365a 817 if (BhkENTRY(hk, which)) \
16c91539 818 BhkENTRY(hk, which)(aTHX_ arg); \
1930840b
BM
819 } \
820 } \
821 } STMT_END
822
d9088386
Z
823/* flags for rv2cv_op_cv */
824
825#define RV2CVOPCV_MARK_EARLY 0x00000001
826#define RV2CVOPCV_RETURN_NAME_GV 0x00000002
211a4342 827#define RV2CVOPCV_RETURN_STUB 0x00000004
9c98a81f
FC
828#ifdef PERL_CORE /* behaviour of this flag is subject to change: */
829# define RV2CVOPCV_MAYBE_NAME_GV 0x00000008
830#endif
831#define RV2CVOPCV_FLAG_MASK 0x0000000f /* all of the above */
d9088386 832
d3d7d28f
FC
833#define op_lvalue(op,t) Perl_op_lvalue_flags(aTHX_ op,t,0)
834
f5d552b4
FC
835/* flags for op_lvalue_flags */
836
837#define OP_LVALUE_NO_CROAK 1
838
9733086d
BM
839/*
840=head1 Custom Operators
841
842=for apidoc Am|U32|XopFLAGS|XOP *xop
843Return the XOP's flags.
844
845=for apidoc Am||XopENTRY|XOP *xop|which
2d7f6611 846Return a member of the XOP structure. C<which> is a cpp token
72d33970
FC
847indicating which entry to return. If the member is not set
848this will return a default value. The return type depends
2d7f6611 849on C<which>. This macro evaluates its arguments more than
72d33970 850once. If you are using C<Perl_custom_op_xop> to retreive a
ae103e09
DD
851C<XOP *> from a C<OP *>, use the more efficient L</XopENTRYCUSTOM> instead.
852
853=for apidoc Am||XopENTRYCUSTOM|const OP *o|which
854Exactly like C<XopENTRY(XopENTRY(Perl_custom_op_xop(aTHX_ o), which)> but more
2d7f6611 855efficient. The C<which> parameter is identical to L</XopENTRY>.
9733086d
BM
856
857=for apidoc Am|void|XopENTRY_set|XOP *xop|which|value
2d7f6611 858Set a member of the XOP structure. C<which> is a cpp token
72d33970
FC
859indicating which entry to set. See L<perlguts/"Custom Operators">
860for details about the available members and how
861they are used. This macro evaluates its argument
ae103e09 862more than once.
9733086d
BM
863
864=for apidoc Am|void|XopDISABLE|XOP *xop|which
865Temporarily disable a member of the XOP, by clearing the appropriate flag.
866
867=for apidoc Am|void|XopENABLE|XOP *xop|which
868Reenable a member of the XOP which has been disabled.
869
870=cut
871*/
872
1830b3d9
BM
873struct custom_op {
874 U32 xop_flags;
875 const char *xop_name;
876 const char *xop_desc;
877 U32 xop_class;
878 void (*xop_peep)(pTHX_ OP *o, OP *oldop);
879};
880
ae103e09
DD
881/* return value of Perl_custom_op_get_field, similar to void * then casting but
882 the U32 doesn't need truncation on 64 bit platforms in the caller, also
883 for easier macro writing */
884typedef union {
885 const char *xop_name;
886 const char *xop_desc;
887 U32 xop_class;
888 void (*xop_peep)(pTHX_ OP *o, OP *oldop);
889 XOP *xop_ptr;
890} XOPRETANY;
891
1830b3d9
BM
892#define XopFLAGS(xop) ((xop)->xop_flags)
893
894#define XOPf_xop_name 0x01
895#define XOPf_xop_desc 0x02
896#define XOPf_xop_class 0x04
897#define XOPf_xop_peep 0x08
898
ae103e09
DD
899/* used by Perl_custom_op_get_field for option checking */
900typedef enum {
901 XOPe_xop_ptr = 0, /* just get the XOP *, don't look inside it */
902 XOPe_xop_name = XOPf_xop_name,
903 XOPe_xop_desc = XOPf_xop_desc,
904 XOPe_xop_class = XOPf_xop_class,
4a3798ca 905 XOPe_xop_peep = XOPf_xop_peep
ae103e09
DD
906} xop_flags_enum;
907
1830b3d9
BM
908#define XOPd_xop_name PL_op_name[OP_CUSTOM]
909#define XOPd_xop_desc PL_op_desc[OP_CUSTOM]
910#define XOPd_xop_class OA_BASEOP
911#define XOPd_xop_peep ((Perl_cpeep_t)0)
912
913#define XopENTRY_set(xop, which, to) \
914 STMT_START { \
915 (xop)->which = (to); \
916 (xop)->xop_flags |= XOPf_ ## which; \
917 } STMT_END
918
919#define XopENTRY(xop, which) \
920 ((XopFLAGS(xop) & XOPf_ ## which) ? (xop)->which : XOPd_ ## which)
921
ae103e09
DD
922#define XopENTRYCUSTOM(o, which) \
923 (Perl_custom_op_get_field(aTHX_ o, XOPe_ ## which).which)
924
1830b3d9
BM
925#define XopDISABLE(xop, which) ((xop)->xop_flags &= ~XOPf_ ## which)
926#define XopENABLE(xop, which) \
927 STMT_START { \
928 (xop)->xop_flags |= XOPf_ ## which; \
929 assert(XopENTRY(xop, which)); \
930 } STMT_END
931
ae103e09
DD
932#define Perl_custom_op_xop(x) \
933 (Perl_custom_op_get_field(x, XOPe_xop_ptr).xop_ptr)
934
9733086d
BM
935/*
936=head1 Optree Manipulation Functions
937
938=for apidoc Am|const char *|OP_NAME|OP *o
72d33970 939Return the name of the provided OP. For core ops this looks up the name
9733086d
BM
940from the op_type; for custom ops from the op_ppaddr.
941
942=for apidoc Am|const char *|OP_DESC|OP *o
943Return a short description of the provided OP.
944
945=for apidoc Am|U32|OP_CLASS|OP *o
946Return the class of the provided OP: that is, which of the *OP
72d33970 947structures it uses. For core ops this currently gets the information out
e8f6c72a
DM
948of C<PL_opargs>, which does not always accurately reflect the type used;
949in v5.26 onwards, see also the function C<L</op_class>> which can do a better
950job of determining the used type.
951
9733086d 952For custom ops the type is returned from the registration, and it is up
72d33970 953to the registree to ensure it is accurate. The value returned will be
796b6530 954one of the C<OA_>* constants from F<op.h>.
9733086d 955
5bfb0af0 956=for apidoc Am|bool|OP_TYPE_IS|OP *o|Optype type
796b6530 957Returns true if the given OP is not a C<NULL> pointer
11ee9dd6
SM
958and if it is of the given type.
959
960The negation of this macro, C<OP_TYPE_ISNT> is also available
961as well as C<OP_TYPE_IS_NN> and C<OP_TYPE_ISNT_NN> which elide
962the NULL pointer check.
963
5bfb0af0 964=for apidoc Am|bool|OP_TYPE_IS_OR_WAS|OP *o|Optype type
11ee9dd6
SM
965Returns true if the given OP is not a NULL pointer and
966if it is of the given type or used to be before being
967replaced by an OP of type OP_NULL.
968
969The negation of this macro, C<OP_TYPE_ISNT_AND_WASNT>
970is also available as well as C<OP_TYPE_IS_OR_WAS_NN>
971and C<OP_TYPE_ISNT_AND_WASNT_NN> which elide
796b6530 972the C<NULL> pointer check.
11ee9dd6 973
e6dae479 974=for apidoc Am|bool|OpHAS_SIBLING|OP *o
796b6530 975Returns true if C<o> has a sibling
1ed44841 976
5e24af7d 977=for apidoc Am|OP*|OpSIBLING|OP *o
796b6530 978Returns the sibling of C<o>, or C<NULL> if there is no sibling
1ed44841 979
5e24af7d 980=for apidoc Am|void|OpMORESIB_set|OP *o|OP *sib
796b6530 981Sets the sibling of C<o> to the non-zero value C<sib>. See also C<L</OpLASTSIB_set>>
fbe13c60
KW
982and C<L</OpMAYBESIB_set>>. For a higher-level interface, see
983C<L</op_sibling_splice>>.
5e24af7d
DM
984
985=for apidoc Am|void|OpLASTSIB_set|OP *o|OP *parent
0f9a6232 986Marks C<o> as having no further siblings and marks
fbe13c60 987o as having the specified parent. See also C<L</OpMORESIB_set>> and
5e24af7d 988C<OpMAYBESIB_set>. For a higher-level interface, see
fbe13c60 989C<L</op_sibling_splice>>.
5e24af7d
DM
990
991=for apidoc Am|void|OpMAYBESIB_set|OP *o|OP *sib|OP *parent
992Conditionally does C<OpMORESIB_set> or C<OpLASTSIB_set> depending on whether
796b6530 993C<sib> is non-null. For a higher-level interface, see C<L</op_sibling_splice>>.
1ed44841 994
9733086d
BM
995=cut
996*/
997
1830b3d9 998#define OP_NAME(o) ((o)->op_type == OP_CUSTOM \
ae103e09 999 ? XopENTRYCUSTOM(o, xop_name) \
1830b3d9
BM
1000 : PL_op_name[(o)->op_type])
1001#define OP_DESC(o) ((o)->op_type == OP_CUSTOM \
ae103e09 1002 ? XopENTRYCUSTOM(o, xop_desc) \
1830b3d9
BM
1003 : PL_op_desc[(o)->op_type])
1004#define OP_CLASS(o) ((o)->op_type == OP_CUSTOM \
ae103e09 1005 ? XopENTRYCUSTOM(o, xop_class) \
1830b3d9
BM
1006 : (PL_opargs[(o)->op_type] & OA_CLASS_MASK))
1007
437e3a7d 1008#define OP_TYPE_IS(o, type) ((o) && (o)->op_type == (type))
11ee9dd6
SM
1009#define OP_TYPE_IS_NN(o, type) ((o)->op_type == (type))
1010#define OP_TYPE_ISNT(o, type) ((o) && (o)->op_type != (type))
1011#define OP_TYPE_ISNT_NN(o, type) ((o)->op_type != (type))
1012
1013#define OP_TYPE_IS_OR_WAS_NN(o, type) \
1014 ( ((o)->op_type == OP_NULL \
1015 ? (o)->op_targ \
1016 : (o)->op_type) \
1017 == (type) )
1018
1019#define OP_TYPE_IS_OR_WAS(o, type) \
1020 ( (o) && OP_TYPE_IS_OR_WAS_NN(o, type) )
1021
1022#define OP_TYPE_ISNT_AND_WASNT_NN(o, type) \
1023 ( ((o)->op_type == OP_NULL \
1024 ? (o)->op_targ \
1025 : (o)->op_type) \
1026 != (type) )
1027
1028#define OP_TYPE_ISNT_AND_WASNT(o, type) \
1029 ( (o) && OP_TYPE_ISNT_AND_WASNT_NN(o, type) )
437e3a7d 1030
1d31efef
DIM
1031/* should match anything that uses ck_ftst in regen/opcodes */
1032#define OP_IS_STAT(op) (OP_IS_FILETEST(op) || (op) == OP_LSTAT || (op) == OP_STAT)
5e24af7d 1033
87b5a8b9
DM
1034# define OpHAS_SIBLING(o) (cBOOL((o)->op_moresib))
1035# define OpSIBLING(o) (0 + (o)->op_moresib ? (o)->op_sibparent : NULL)
5e24af7d
DM
1036# define OpMORESIB_set(o, sib) ((o)->op_moresib = 1, (o)->op_sibparent = (sib))
1037# define OpLASTSIB_set(o, parent) \
1038 ((o)->op_moresib = 0, (o)->op_sibparent = (parent))
1039# define OpMAYBESIB_set(o, sib, parent) \
1040 ((o)->op_sibparent = ((o)->op_moresib = cBOOL(sib)) ? (sib) : (parent))
5e24af7d 1041
e6dae479 1042#if !defined(PERL_CORE) && !defined(PERL_EXT)
5e24af7d 1043/* for backwards compatibility only */
e6dae479 1044# define OP_SIBLING(o) OpSIBLING(o)
29e61fd9 1045#endif
1ed44841 1046
e8f91c91
DD
1047#define newATTRSUB(f, o, p, a, b) Perl_newATTRSUB_x(aTHX_ f, o, p, a, b, FALSE)
1048#define newSUB(f, o, p, b) newATTRSUB((f), (o), (p), NULL, (b))
7bff8c33 1049
3f2908ec 1050/*
e8570548
Z
1051=head1 Hook manipulation
1052*/
1053
1054#ifdef USE_ITHREADS
1055# define OP_CHECK_MUTEX_INIT MUTEX_INIT(&PL_check_mutex)
1056# define OP_CHECK_MUTEX_LOCK MUTEX_LOCK(&PL_check_mutex)
1057# define OP_CHECK_MUTEX_UNLOCK MUTEX_UNLOCK(&PL_check_mutex)
1058# define OP_CHECK_MUTEX_TERM MUTEX_DESTROY(&PL_check_mutex)
1059#else
1060# define OP_CHECK_MUTEX_INIT NOOP
1061# define OP_CHECK_MUTEX_LOCK NOOP
1062# define OP_CHECK_MUTEX_UNLOCK NOOP
1063# define OP_CHECK_MUTEX_TERM NOOP
1064#endif
1065
fedf30e1
DM
1066
1067/* Stuff for OP_MULTDEREF/pp_multideref. */
1068
1069/* actions */
1070
1071/* Load another word of actions/flag bits. Must be 0 */
1072#define MDEREF_reload 0
1073
1074#define MDEREF_AV_pop_rv2av_aelem 1
1075#define MDEREF_AV_gvsv_vivify_rv2av_aelem 2
1076#define MDEREF_AV_padsv_vivify_rv2av_aelem 3
1077#define MDEREF_AV_vivify_rv2av_aelem 4
1078#define MDEREF_AV_padav_aelem 5
1079#define MDEREF_AV_gvav_aelem 6
1080
1081#define MDEREF_HV_pop_rv2hv_helem 8
1082#define MDEREF_HV_gvsv_vivify_rv2hv_helem 9
1083#define MDEREF_HV_padsv_vivify_rv2hv_helem 10
1084#define MDEREF_HV_vivify_rv2hv_helem 11
1085#define MDEREF_HV_padhv_helem 12
1086#define MDEREF_HV_gvhv_helem 13
1087
1088#define MDEREF_ACTION_MASK 0xf
1089
1090/* key / index type */
1091
1092#define MDEREF_INDEX_none 0x00 /* run external ops to generate index */
1093#define MDEREF_INDEX_const 0x10 /* index is const PV/UV */
1094#define MDEREF_INDEX_padsv 0x20 /* index is lexical var */
1095#define MDEREF_INDEX_gvsv 0x30 /* index is GV */
1096
1097#define MDEREF_INDEX_MASK 0x30
1098
1099/* bit flags */
1100
1101#define MDEREF_FLAG_last 0x40 /* the last [ah]elem; PL_op flags apply */
1102
1103#define MDEREF_MASK 0x7F
1104#define MDEREF_SHIFT 7
1105
87e05d1a 1106#if defined(PERL_IN_DOOP_C) || defined(PERL_IN_PP_C)
814eedc8
DD
1107# define FATAL_ABOVE_FF_MSG \
1108 "Use of strings with code points over 0xFF as arguments to " \
1109 "%s operator is not allowed"
1110# define DEPRECATED_ABOVE_FF_MSG \
1111 "Use of strings with code points over 0xFF as arguments to " \
1112 "%s operator is deprecated. This will be a fatal error in " \
1113 "Perl 5.32"
87e05d1a
KW
1114#endif
1115
fedf30e1 1116
e8570548 1117/*
14d04a33 1118 * ex: set ts=8 sts=4 sw=4 et:
3f2908ec 1119 */