This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
move OPpTARGET_MY comments from opcode.pl
[perl5.git] / regen / op_private
CommitLineData
f3574cc6
DM
1#!perl
2
3=head1 F<regen/op_private>
4
5This file contains all the definitions of the meanings of the flags in the
6op_private field of an OP.
7
8After editing this file, run C<make regen>. This will generate/update data
9in:
10
11 opcode.h
12 lib/B/Op_private.pm
13
14C<B::Op_private> holds three global hashes, C<%bits>, C<%defines>,
15C<%labels>, which hold roughly the same information as found in this file
16(after processing).
17
18F<opcode.h> gains a series of C<OPp*> defines, and a few static data
19structures:
20
c10dbd97
DM
21C<PL_op_private_valid> defines, per-op, which op_private bits are legally
22allowed to be set. This is a good first place to look to see if an op has
f3574cc6
DM
23any spare private bits.
24
25C<PL_op_private_bitdef_ix>, C<PL_op_private_bitdefs>,
26C<PL_op_private_labels>, C<PL_op_private_bitfields>,
27C<PL_op_private_valid> contain (in a compact form) the data needed by
28Perl_do_op_dump() to dump the op_private field of an op.
29
30This file actually contains perl code which is run by F<regen/opcode.pl>.
31The basic idea is that you keep calling addbits() to add definitions of
32what a particular bit or range of bits in op_private means for a
33particular op. This can be specified either as a 1-bit flag or a 1-or-more
34bit bit field. Here's a general example:
35
36 addbits('aelem',
37 7 => qw(OPpLVAL_INTRO LVINTRO),
38 '5..6' => {
39 mask_def => 'OPpDEREF',
40 enum => [ qw(
41 1 OPpDEREF_AV DREFAV
42 2 OPpDEREF_HV DREFHV
43 3 OPpDEREF_SV DREFSV
44 )],
45 },
46 4 => qw(OPpLVAL_DEFER LVDEFER),
47 );
48
49Here for the op C<aelem>, bits 4 and 7 (bits are numbered 0..7) are
50defined as single-bit flags. The first string following the bit number is
51the define name that gets emitted in F<opcode.h>, and the second string is
52the label, which will be displayed by F<Concise.pm> and Perl_do_op_dump()
53(as used by C<perl -Dx>).
54
55If the bit number is actually two numbers connected with '..', then this
56defines a bit field, which is 1 or more bits taken to hold a small
57unsigned integer. Instead of two string arguments, it just has a single
58hash ref argument. A bit field allows you to generate extra defines, such
59as a mask, and optionally allows you to define an enumeration, where a
60subset of the possible values of the bit field are given their own defines
61and labels. The full syntax of this hash is explained further below.
62
63Note that not all bits for a particular op need to be added in a single
64addbits() call; they accumulate. In particular, this file is arranged in
65two halves; first, generic flags shared by multiple ops are added, then
66in the second half, specific per-op flags are added, e.g.
67
68 addbits($_, 7 => qw(OPpLVAL_INTRO LVINTRO)) for qw(pos substr vec ...);
69
70 ....
71
72 addbits('substr',
73 4 => qw(OPpSUBSTR_REPL_FIRST REPL1ST),
74 3 => ...
75 );
76
c10dbd97
DM
77(although the dividing line between these two halves is somewhat
78subjective, and is based on whether "OPp" is followed by the op name or
79something generic).
f3574cc6
DM
80
81There are some utility functions for generating a list of ops from
82F<regen/opcodes> based on various criteria. These are:
83
84 ops_with_check('ck_foo')
85 ops_with_flag('X')
86 ops_with_arg(N, 'XYZ')
87
c10dbd97 88which respectively return a list of op names where:
f3574cc6
DM
89
90 field 3 of regen/opcodes specifies 'ck_foo' as the check function;
91 field 4 of of regen/opcodes has flag or type 'X' set;
92 argument field N of of regen/opcodes matches 'XYZ';
93
94For example
95
96 addbits($_, 4 => qw(OPpTARGET_MY TARGMY)) for ops_with_flag('T');
97
98If a label is specified as '-', then the flag or bit field is not
99displayed symbolically by Concise/-Dx; instead the bits are treated as
c10dbd97
DM
100unrecognised and are included in the final residual integer value after
101all recognised bits have been processed (this doesn't apply to individual
f3574cc6
DM
102enum labels).
103
104Here is a full example of a bit field hash:
105
106 '5..6' => {
107 mask_def => 'OPpFOO_MASK',
108 baseshift_def => 'OPpFOO_SHIFT',
109 bitcount_def => 'OPpFOO_BITS',
110 label => 'FOO',
111 enum => [ qw(
112 1 OPpFOO_A A
113 2 OPpFOO_B B
114 3 OPpFOO_C C
115 )],
116 };
117
118The optional C<*_def> keys cause defines to be emitted that specify
119useful values based on the bit range (5 to 6 in this case):
120
121 mask_def: a mask that will extract the bit field
122 baseshift_def: how much to shift to make the bit field reach bit 0
123 bitcount_def: how many bits make up the bit field
124
125The example above will generate
126
127 #define OPpFOO_MASK 0x60
128 #define OPpFOO_SHIFT 5
129 #define OPpFOO_BITS 2
130
131The optional enum list specifies a set of defines and labels for (possibly
132a subset of) the possible values of the bit field (which in this example
133are 0,1,2,3). If a particular value matches an enum, then it will be
134displayed symbolically (e.g. 'C'), otherwise as a small integer. The
135defines are suitably shifted. The example above will generate
136
137 #define OPpFOO_A 0x20
138 #define OPpFOO_B 0x40
139 #define OPpFOO_C 0x60
140
141So you can write code like
142
143 if ((o->op_private & OPpFOO_MASK) == OPpFOO_C) ...
144
145The optional 'label' key causes Concise/-Dx output to prefix the value
146with C<LABEL=>; so in this case it might display C<FOO=C>. If the field
147value is zero, and if no label is present, and if no enum matches, then
148the field isn't displayed.
149
150=cut
151
152
153use warnings;
154use strict;
155
156
157
158
159# ====================================================================
160#
161# GENERIC OPpFOO flags
162#
163# Flags where FOO is a generic term (like LVAL), and the flag is
164# shared between multiple (possibly unrelated) ops.
165
166
167
168
169{
170 # The lower few bits of op_private often indicate the number of
171 # arguments. This is usually set by newUNOP() and newLOGOP (to 1),
172 # by newBINOP() (to 1 or 2), and by ck_fun() (to 1..15).
173 #
174 # These values are sometimes used at runtime: in particular,
175 # the MAXARG macro extracts out the lower 4 bits.
176 #
177 # Some ops encroach upon these bits; for example, entersub is a unop,
178 # but uses bit 0 for something else. Bit 0 is initially set to 1 in
179 # newUNOP(), but is later cleared (in ck_rvconst()), when the code
180 # notices that this op is an entersub.
181 #
182 # The important thing below is that any ops which use MAXARG at
183 # runtime must have all 4 bits allocated; if bit 3 were used for a new
184 # flag say, then things could break. The information on the other
185 # types of op is for completeness (so we can account for every bit
186 # used in every op)
187
188 my (%maxarg, %args0, %args1, %args2, %args3, %args4);
189
190 # these are the functions which currently use MAXARG at runtime
191 # (i.e. in the pp() functions). Thus they must always have 4 bits
192 # allocated
193 $maxarg{$_} = 1 for qw(
194 binmode bless caller chdir close enterwrite eof exit fileno getc
195 getpgrp gmtime index mkdir rand reset setpgrp sleep srand sysopen
196 tell umask
197 );
198
199 # find which ops use 0,1,2,3 or 4 bits of op_private for arg count info
200
201 $args0{$_} = 1 for qw(entersub); # UNOPs that usurp bit 0
202
203 $args1{$_} = 1 for (
204 qw(reverse), # ck_fun(), but most bits stolen
205 grep !$maxarg{$_} && !$args0{$_},
206 ops_with_flag('1'), # UNOP
207 ops_with_flag('%'), # BASEOP/UNOP
208 ops_with_flag('|'), # LOGOP
209 ops_with_flag('-'), # FILESTATOP
210 ops_with_flag('}'), # LOOPEXOP
211 );
212
213 $args2{$_} = 1 for (
214 qw(vec),
215 grep !$maxarg{$_} && !$args0{$_} && !$args1{$_},
216 ops_with_flag('2'), # BINOP
217 # this is a binop, but special-cased as a
218 # baseop in regen/opcodes
219 'sassign',
220 );
221
222 $args3{$_} = 1 for grep !$maxarg{$_} && !$args0{$_}
223 && !$args1{$_} && !$args2{$_},
224 # substr starts off with 4 bits set in
225 # ck_fun(), but since it never has more than 7
226 # args, bit 3 is later stolen
227 qw(substr);
228
229 $args4{$_} = 1 for keys %maxarg,
230 grep !$args0{$_} && !$args1{$_}
231 && !$args2{$_} && !$args3{$_},
232 ops_with_check('ck_fun'),
233 # these other ck_*() functions call ck_fun()
234 ops_with_check('ck_exec'),
235 ops_with_check('ck_glob'),
236 ops_with_check('ck_index'),
237 ops_with_check('ck_join'),
238 ops_with_check('ck_lfun'),
239 ops_with_check('ck_open'),
240 ops_with_check('ck_select'),
241 ops_with_check('ck_tell'),
242 ops_with_check('ck_trunc'),
243 ;
244
245
246 for (sort keys %args1) {
247 addbits($_, '0..0' => {
248 mask_def => 'OPpARG1_MASK',
249 label => '-',
250 }
251 );
252 }
253
254 for (sort keys %args2) {
255 addbits($_, '0..1' => {
256 mask_def => 'OPpARG2_MASK',
257 label => '-',
258 }
259 );
260 }
261
262 for (sort keys %args3) {
263 addbits($_, '0..2' => {
264 mask_def => 'OPpARG3_MASK',
265 label => '-',
266 }
267 );
268 }
269
270 for (sort keys %args4) {
271 addbits($_, '0..3' => {
272 mask_def => 'OPpARG4_MASK',
273 label => '-',
274 }
275 );
276 }
277}
278
279
280
281# if NATIVE_HINTS is defined, op_private on cops holds the top 8 bits
282# of PL_hints, although only bits 6 & 7 are officially used for that
283# purpose (the rest ought to be masked off). Bit 5 is set separately
284
285for (qw(nextstate dbstate)) {
286 addbits($_,
287 5 => qw(OPpHUSH_VMSISH HUSH),
288 # should match HINT_M_VMSISH_STATUS, HINT_M_VMSISH_TIME
289 6 => qw(OPpHINT_M_VMSISH_STATUS VMSISH_STATUS),
290 7 => qw(OPpHINT_M_VMSISH_TIME VMSISH_TIME),
291
292 );
293}
294
295
296
297addbits($_, 7 => qw(OPpLVAL_INTRO LVINTRO))
298 for qw(pos substr vec gvsv rv2sv rv2hv rv2gv rv2av aelem helem aslice
299 hslice delete padsv padav padhv enteriter entersub padrange
300 pushmark cond_expr),
301 'list', # this gets set in my_attrs() for some reason
302 ;
303
304
305
306# TARGLEX
307#
308# in constructs like my $x; ...; $x = $a + $b,
309# the sassign is optimised away and OPpTARGET_MY is set on the add op
b4941db2
DM
310#
311# Note that OPpTARGET_MY is mainly used at compile-time. At run time,
312# the pp function just updates the SV pointed to by op_targ, and doesn't
313# care whether that's a PADTMP or a lexical var.
f3574cc6 314
16a6edfa
DM
315# Some comments about when its safe to use T/OPpTARGET_MY.
316#
317# Safe to set if the ppcode uses:
318# tryAMAGICbin, tryAMAGICun, SETn, SETi, SETu, PUSHn, PUSHTARG, SETTARG,
319# SETs(TARG), XPUSHn, XPUSHu,
320#
321# Unsafe to set if the ppcode uses dTARG or [X]RETPUSH[YES|NO|UNDEF]
322#
323# lt and friends do SETs (including ncmp, but not scmp)
324#
325# Additional mode of failure: the opcode can modify TARG before it "used"
326# all the arguments (or may call an external function which does the same).
327# If the target coincides with one of the arguments ==> kaboom.
328#
329# pp.c pos substr each not OK (RETPUSHUNDEF)
330# substr vec also not OK due to LV to target (are they???)
331# ref not OK (RETPUSHNO)
332# trans not OK (dTARG; TARG = sv_newmortal();)
333# ucfirst etc not OK: TMP arg processed inplace
334# quotemeta not OK (unsafe when TARG == arg)
335# each repeat not OK too due to list context
336# pack split - unknown whether they are safe
337# sprintf: is calling do_sprintf(TARG,...) which can act on TARG
338# before other args are processed.
339#
340# Suspicious wrt "additional mode of failure" (and only it):
341# schop, chop, postinc/dec, bit_and etc, negate, complement.
342#
343# Also suspicious: 4-arg substr, sprintf, uc/lc (POK_only), reverse, pack.
344#
345# substr/vec: doing TAINT_off()???
346#
347# pp_hot.c
348# readline - unknown whether it is safe
349# match subst not OK (dTARG)
350# grepwhile not OK (not always setting)
351# join not OK (unsafe when TARG == arg)
352#
353# Suspicious wrt "additional mode of failure": concat (dealt with
354# in ck_sassign()), join (same).
355#
356# pp_ctl.c
357# mapwhile flip caller not OK (not always setting)
358#
359# pp_sys.c
360# backtick glob warn die not OK (not always setting)
361# warn not OK (RETPUSHYES)
362# open fileno getc sysread syswrite ioctl accept shutdown
363# ftsize(etc) readlink telldir fork alarm getlogin not OK (RETPUSHUNDEF)
364# umask select not OK (XPUSHs(&PL_sv_undef);)
365# fileno getc sysread syswrite tell not OK (meth("FILENO" "GETC"))
366# sselect shm* sem* msg* syscall - unknown whether they are safe
367# gmtime not OK (list context)
368#
369# Suspicious wrt "additional mode of failure": warn, die, select.
370
371
f3574cc6
DM
372addbits($_, 4 => qw(OPpTARGET_MY TARGMY))
373 for ops_with_flag('T'),
374 # This flag is also used to indicate matches against implicit $_,
375 # where $_ is lexical; e.g. my $_; ....; /foo/
376 qw(match subst trans transr);
377;
378
379
380
381
382
383# op_targ carries a refcount
384addbits($_, 6 => qw(OPpREFCOUNTED REFC))
385 for qw(leave leavesub leavesublv leavewrite leaveeval);
386
387
388
389# Do not copy return value
390addbits($_, 7 => qw(OPpLVALUE LV)) for qw(leave leaveloop);
391
392
393
394# Pattern coming in on the stack
395addbits($_, 6 => qw(OPpRUNTIME RTIME))
396 for qw(match subst substcont qr pushre);
397
398
399
400# autovivify: Want ref to something
401for (qw(rv2gv rv2sv padsv aelem helem entersub)) {
402 addbits($_, '5..6' => {
403 mask_def => 'OPpDEREF',
404 enum => [ qw(
405 1 OPpDEREF_AV DREFAV
406 2 OPpDEREF_HV DREFHV
407 3 OPpDEREF_SV DREFSV
408 )],
409 }
410 );
411}
412
413
414
415# Defer creation of array/hash elem
416addbits($_, 4 => qw(OPpLVAL_DEFER LVDEFER)) for qw(aelem helem);
417
418
419
420addbits($_, 2 => qw(OPpSLICEWARNING SLICEWARN)) # warn about @hash{$scalar}
421 for qw(rv2hv rv2av padav padhv hslice aslice);
422
423
424
425# XXX Concise seemed to think that OPpOUR_INTRO is used in rv2gv too,
426# but I can't see it - DAPM
427addbits($_, 4 => qw(OPpOUR_INTRO OURINTR)) # Variable was in an our()
428 for qw(gvsv rv2sv rv2av rv2hv enteriter);
429
430
431
432# We might be an lvalue to return
433addbits($_, 3 => qw(OPpMAYBE_LVSUB LVSUB))
434 for qw(aassign rv2av rv2gv rv2hv padav padhv aelem helem aslice hslice
435 av2arylen keys rkeys kvaslice kvhslice substr pos vec);
436
437
438
439for (qw(rv2hv padhv)) {
440 addbits($_, # e.g. %hash in (%hash || $foo) ...
441 5 => qw(OPpTRUEBOOL BOOL), # ... in void cxt
442 6 => qw(OPpMAYBE_TRUEBOOL BOOL?), # ... cx not known till run time
443 );
444}
445
446
447
c486bd5c 448addbits($_, 1 => qw(OPpHINT_STRICT_REFS STRICT)) for qw(rv2sv rv2av rv2hv rv2gv);
f3574cc6
DM
449
450
451
452# Treat caller(1) as caller(2)
453addbits($_, 7 => qw(OPpOFFBYONE +1)) for qw(caller wantarray runcv);
454
455
456
457# label is in UTF8 */
458addbits($_, 7 => qw(OPpPV_IS_UTF8 UTF)) for qw(last redo next goto dump);
459
460
461
462# ====================================================================
463#
464# OP-SPECIFIC OPpFOO_* flags:
465#
466# where FOO is typically the name of an op, and the flag is used by a
467# single op (or maybe by a few closely related ops).
468
469
470
471addbits($_, 4 => qw(OPpPAD_STATE STATE)) for qw(padav padhv padsv pushmark);
472
473
474
475addbits('aassign', 6 => qw(OPpASSIGN_COMMON COMMON));
476
477
478
479addbits('sassign',
480 6 => qw(OPpASSIGN_BACKWARDS BKWARD), # Left & right switched
481 7 => qw(OPpASSIGN_CV_TO_GV CV2GV), # Possible optimisation for constants
482);
483
484
485
486for (qw(trans transr)) {
487 addbits($_,
488 0 => qw(OPpTRANS_FROM_UTF <UTF),
489 1 => qw(OPpTRANS_TO_UTF >UTF),
490 2 => qw(OPpTRANS_IDENTICAL IDENT), # right side is same as left
491 3 => qw(OPpTRANS_SQUASH SQUASH),
492 # 4 is used for OPpTARGET_MY
493 5 => qw(OPpTRANS_COMPLEMENT COMPL),
494 6 => qw(OPpTRANS_GROWS GROWS),
495 7 => qw(OPpTRANS_DELETE DEL),
496 );
497}
498
499
500
501addbits('repeat', 6 => qw(OPpREPEAT_DOLIST DOLIST)); # List replication
502
503
504
505# OP_ENTERSUB and OP_RV2CV flags
506#
507# Flags are set on entersub and rv2cv in three phases:
508# parser - the parser passes the flag to the op constructor
509# check - the check routine called by the op constructor sets the flag
510# context - application of scalar/ref/lvalue context applies the flag
511#
512# In the third stage, an entersub op might turn into an rv2cv op (undef &foo,
513# \&foo, lock &foo, exists &foo, defined &foo). The two places where that
514# happens (op_lvalue_flags and doref in op.c) need to make sure the flags do
515# not conflict, since some flags with different meanings overlap between
516# the two ops. Flags applied in the context phase are only set when there
517# is no conversion of op type.
518#
519# bit entersub flag phase rv2cv flag phase
520# --- ------------- ----- ---------- -----
521# 0 OPpENTERSUB_INARGS context
522# 1 HINT_STRICT_REFS check HINT_STRICT_REFS check
523# 2 OPpENTERSUB_HASTARG check
524# 3 OPpENTERSUB_AMPER check OPpENTERSUB_AMPER parser
525# 4 OPpENTERSUB_DB check
526# 5 OPpDEREF_AV context
0eb7ca05 527# 6 OPpDEREF_HV context OPpMAY_RETURN_CONSTANT parser/context
f3574cc6
DM
528# 7 OPpLVAL_INTRO context OPpENTERSUB_NOPAREN parser
529
530# NB: OPpHINT_STRICT_REFS must equal HINT_STRICT_REFS
531
532addbits('entersub',
533 0 => qw(OPpENTERSUB_INARGS INARGS), # Lval used as arg to a sub
c486bd5c 534 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope
f3574cc6
DM
535 2 => qw(OPpENTERSUB_HASTARG TARG ), # Called from OP tree
536 3 => qw(OPpENTERSUB_AMPER AMPER), # Used & form to call
537 4 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine
538 # 5..6 => OPpDEREF, already defined above
539 # 7 => OPpLVAL_INTRO, already defined above
540);
541addbits('rv2cv',
542 # If a constant sub, return the constant
c486bd5c 543 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope
f3574cc6
DM
544
545 3 => qw(OPpENTERSUB_AMPER AMPER), # Used & form to call
546
547 6 => qw(OPpMAY_RETURN_CONSTANT CONST),
548 7 => qw(OPpENTERSUB_NOPAREN NO() ), # bare sub call (without parens)
549);
550
551# XXX perhaps ought the clear these flags in Perl_doref when converting
552# and entersub into an rv2cv???? Failing that, update the comments above
553# and add them as part of the main addbits('rv2cv'.
554
555addbits('rv2cv',
556 # If a constant sub, return the constant
557 2 => qw(OPpENTERSUB_HASTARG TARG),
558 4 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine
559);
560
561
562
563#foo() called before sub foo was parsed */
564addbits('gv', 5 => qw(OPpEARLY_CV EARLYCV));
565
566
567
568# 1st arg is replacement string */
569addbits('substr', 4 => qw(OPpSUBSTR_REPL_FIRST REPL1ST));
570
571
572
573addbits('padrange',
574 # bits 0..6 hold target range
575 '0..6' => {
576 label => '-',
577 mask_def => 'OPpPADRANGE_COUNTMASK',
578 bitcount_def => 'OPpPADRANGE_COUNTSHIFT',
579 }
580 # 7 => OPpLVAL_INTRO, already defined above
581);
582
583
584
585for (qw(aelemfast aelemfast_lex)) {
586 addbits($_,
587 '0..7' => {
588 label => '-',
589 }
590 );
591}
592
593
594
595addbits('rv2gv',
596 2 => qw(OPpDONT_INIT_GV NOINIT), # Call gv_fetchpv with GV_NOINIT
597 # (Therefore will return whatever is currently in
598 # the symbol table, not guaranteed to be a PVGV)
599 4 => qw(OPpALLOW_FAKE FAKE), # OK to return fake glob
600);
601
602
603
604addbits('enteriter',
605 2 => qw(OPpITER_REVERSED REVERSED),# for (reverse ...)
c486bd5c 606 3 => qw(OPpITER_DEF DEF), # 'for $_' or 'for my $_'
f3574cc6
DM
607);
608addbits('iter', 2 => qw(OPpITER_REVERSED REVERSED));
609
610
611
612addbits('const',
613 1 => qw(OPpCONST_NOVER NOVER), # no 6;
614 2 => qw(OPpCONST_SHORTCIRCUIT SHORT), # e.g. the constant 5 in (5 || foo)
615 3 => qw(OPpCONST_STRICT STRICT), # bareword subject to strict 'subs'
616 4 => qw(OPpCONST_ENTERED ENTERED), # Has been entered as symbol
617 6 => qw(OPpCONST_BARE BARE), # Was a bare word (filehandle?)
618);
619
620
621
622# Range arg potentially a line num. */
623addbits($_, 6 => qw(OPpFLIP_LINENUM LINENUM)) for qw(flip flop);
624
625
626
627# Guessed that pushmark was needed. */
628addbits('list', 6 => qw(OPpLIST_GUESSED GUESSED));
629
630
631
632# Operating on a list of keys
633addbits('delete', 6 => qw(OPpSLICE SLICE));
634# also 7 => OPpLVAL_INTRO, already defined above
635
636
637
638# Checking for &sub, not {} or [].
639addbits('exists', 6 => qw(OPpEXISTS_SUB SUB));
640
641
642
643addbits('sort',
644 0 => qw(OPpSORT_NUMERIC NUM ), # Optimized away { $a <=> $b }
645 1 => qw(OPpSORT_INTEGER INT ), # Ditto while under "use integer"
646 2 => qw(OPpSORT_REVERSE REV ), # Reversed sort
647 3 => qw(OPpSORT_INPLACE INPLACE), # sort in-place; eg @a = sort @a
648 4 => qw(OPpSORT_DESCEND DESC ), # Descending sort
649 5 => qw(OPpSORT_QSORT QSORT ), # Use quicksort (not mergesort)
650 6 => qw(OPpSORT_STABLE STABLE ), # Use a stable algorithm
651);
652
653
654
655# reverse in-place (@a = reverse @a) */
656addbits('reverse', 3 => qw(OPpREVERSE_INPLACE INPLACE));
657
658
659
660for (qw(open backtick)) {
661 addbits($_,
662 4 => qw(OPpOPEN_IN_RAW INBIN ), # binmode(F,":raw") on input fh
663 5 => qw(OPpOPEN_IN_CRLF INCR ), # binmode(F,":crlf") on input fh
664 6 => qw(OPpOPEN_OUT_RAW OUTBIN), # binmode(F,":raw") on output fh
665 7 => qw(OPpOPEN_OUT_CRLF OUTCR ), # binmode(F,":crlf") on output fh
666 );
667}
668
669
670
671# The various OPpFT* filetest ops
672
673# "use filetest 'access'" is in scope:
674# this flag is set only on a subset of the FT* ops
675addbits($_, 1 => qw(OPpFT_ACCESS FTACCESS)) for ops_with_arg(0, 'F-+');
676
677# all OPpFT* ops except stat and lstat
678for (grep { $_ !~ /^l?stat$/ } ops_with_flag('-')) {
679 addbits($_,
680 2 => qw(OPpFT_STACKED FTSTACKED ), # stacked filetest,
681 # e.g. "-f" in "-f -x $foo"
682 3 => qw(OPpFT_STACKING FTSTACKING), # stacking filetest.
683 # e.g. "-x" in "-f -x $foo"
684 4 => qw(OPpFT_AFTER_t FTAFTERt ), # previous op was -t
685 );
686}
687
688
689
690addbits($_, 1 => qw(OPpGREP_LEX GREPLEX)) # iterate over lexical $_
691 for qw(mapwhile mapstart grepwhile grepstart);
692
693
694
695addbits('entereval',
696 1 => qw(OPpEVAL_HAS_HH HAS_HH ), # Does it have a copy of %^H ?
697 2 => qw(OPpEVAL_UNICODE UNI ),
698 3 => qw(OPpEVAL_BYTES BYTES ),
699 4 => qw(OPpEVAL_COPHH COPHH ), # Construct %^H from COP hints
c486bd5c 700 5 => qw(OPpEVAL_RE_REPARSING REPARSE), # eval_sv(..., G_RE_REPARSING)
f3574cc6
DM
701);
702
703
704
705# These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE.
706# See pp.c:S_rv2gv. */
707addbits('coreargs',
708 0 => qw(OPpCOREARGS_DEREF1 DEREF1), # Arg 1 is a handle constructor
709 1 => qw(OPpCOREARGS_DEREF2 DEREF2), # Arg 2 is a handle constructor
710 #2 reserved for OPpDONT_INIT_GV in rv2gv
711 #4 reserved for OPpALLOW_FAKE in rv2gv
712 6 => qw(OPpCOREARGS_SCALARMOD $MOD ), # \$ rather than \[$@%*]
713 7 => qw(OPpCOREARGS_PUSHMARK MARK ), # Call pp_pushmark
714);
715
716
717
718addbits('split', 7 => qw(OPpSPLIT_IMPLIM IMPLIM)); # implicit limit
719
7201;
721
722# ex: set ts=8 sts=4 sw=4 et: