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