perlop: fix documentation for s/// "false" return value
[perl.git] / regen / op_private
1 #!perl
2
3 =head1 F<regen/op_private>
4
5 This file contains all the definitions of the meanings of the flags in the
6 op_private field of an OP.
7
8 After editing this file, run C<make regen>. This will generate/update data
9 in:
10
11     opcode.h
12     lib/B/Op_private.pm
13
14 C<B::Op_private> holds three global hashes, C<%bits>, C<%defines>,
15 C<%labels>, which hold roughly the same information as found in this file
16 (after processing).
17
18 F<opcode.h> gains a series of C<OPp*> defines, and a few static data
19 structures:
20
21 C<PL_op_private_valid> defines, per-op, which op_private bits are legally
22 allowed to be set. This is a good first place to look to see if an op has
23 any spare private bits.
24
25 C<PL_op_private_bitdef_ix>, C<PL_op_private_bitdefs>,
26 C<PL_op_private_labels>, C<PL_op_private_bitfields>,
27 C<PL_op_private_valid> contain (in a compact form) the data needed by
28 Perl_do_op_dump() to dump the op_private field of an op.
29
30 This file actually contains perl code which is run by F<regen/opcode.pl>.
31 The basic idea is that you keep calling addbits() to add definitions of
32 what a particular bit or range of bits in op_private means for a
33 particular op. This can be specified either as a 1-bit flag or a 1-or-more
34 bit bit field. Here's a general example:
35
36     addbits('aelem',
37             7 => qw(OPpLVAL_INTRO LVINTRO),
38             6 => qw(OPpLVAL_DEFER LVDEFER),
39        '4..5' =>  {
40                        mask_def  => 'OPpDEREF',
41                        enum => [ qw(
42                                    1   OPpDEREF_AV   DREFAV
43                                    2   OPpDEREF_HV   DREFHV
44                                    3   OPpDEREF_SV   DREFSV
45                                )],
46                    },
47     );
48
49 Here for the op C<aelem>, bits 6 and 7 (bits are numbered 0..7) are
50 defined as single-bit flags. The first string following the bit number is
51 the define name that gets emitted in F<opcode.h>, and the second string is
52 the label, which will be displayed by F<Concise.pm> and Perl_do_op_dump()
53 (as used by C<perl -Dx>).
54
55 If the bit number is actually two numbers connected with '..', then this
56 defines a bit field, which is 1 or more bits taken to hold a small
57 unsigned integer. Instead of two string arguments, it just has a single
58 hash ref argument. A bit field allows you to generate extra defines, such
59 as a mask, and optionally allows you to define an enumeration, where a
60 subset of the possible values of the bit field are given their own defines
61 and labels. The full syntax of this hash is explained further below.
62
63 Note that not all bits for a particular op need to be added in a single
64 addbits() call; they accumulate. In particular, this file is arranged in
65 two halves; first, generic flags shared by multiple ops are added, then
66 in 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
77 (although the dividing line between these two halves is somewhat
78 subjective, and is based on whether "OPp" is followed by the op name or
79 something generic).
80
81 There are some utility functions for generating a list of ops from
82 F<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
88 which respectively return a list of op names where:
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
94 For example
95
96     addbits($_, 4 => qw(OPpTARGET_MY TARGMY)) for ops_with_flag('T');
97
98 If a label is specified as '-', then the flag or bit field is not
99 displayed symbolically by Concise/-Dx; instead the bits are treated as
100 unrecognised and are included in the final residual integer value after
101 all recognised bits have been processed (this doesn't apply to individual
102 enum labels).
103
104 Here 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
118 The optional C<*_def> keys cause defines to be emitted that specify
119 useful 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
125 The example above will generate
126
127     #define OPpFOO_MASK 0x60
128     #define OPpFOO_SHIFT   5
129     #define OPpFOO_BITS    2
130
131 The optional enum list specifies a set of defines and labels for (possibly
132 a subset of) the possible values of the bit field (which in this example
133 are 0,1,2,3). If a particular value matches an enum, then it will be
134 displayed symbolically (e.g. 'C'), otherwise as a small integer. The
135 defines 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
141 So you can write code like
142
143     if ((o->op_private & OPpFOO_MASK) == OPpFOO_C) ...
144
145 The optional 'label' key causes Concise/-Dx output to prefix the value
146 with C<LABEL=>; so in this case it might display C<FOO=C>.  If the field
147 value is zero, and if no label is present, and if no enum matches, then
148 the field isn't displayed.
149
150 =cut
151
152
153 use warnings;
154 use 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 avhvswitch
202                        rv2hv);                  # UNOPs that usurp bit 0
203
204     $args1{$_} = 1 for (
205                         qw(reverse), # ck_fun(), but most bits stolen
206                         qw(mapstart grepstart), # set in ck_fun, but
207                                                 # cleared in ck_grep,
208                                                 # unless there is an error
209                         grep !$maxarg{$_} && !$args0{$_},
210                             ops_with_flag('1'), # UNOP
211                             ops_with_flag('+'), # UNOP_AUX
212                             ops_with_flag('%'), # BASEOP/UNOP
213                             ops_with_flag('|'), # LOGOP
214                             ops_with_flag('-'), # FILESTATOP
215                             ops_with_flag('}'), # LOOPEXOP
216                             ops_with_flag('.'), # METHOP
217                     );
218
219     $args2{$_} = 1 for (
220                         qw(vec),
221                         grep !$maxarg{$_} && !$args0{$_} && !$args1{$_},
222                             ops_with_flag('2'), # BINOP
223                     );
224
225     $args3{$_} = 1 for grep !$maxarg{$_} && !$args0{$_}
226                                             && !$args1{$_} && !$args2{$_},
227                             # substr starts off with 4 bits set in
228                             # ck_fun(), but since it never has more than 7
229                             # args, bit 3 is later stolen
230                             qw(substr);
231
232     $args4{$_} = 1 for  keys %maxarg,
233                         grep !$args0{$_} && !$args1{$_}
234                                                 && !$args2{$_} && !$args3{$_},
235                             ops_with_check('ck_fun'),
236                             # these other ck_*() functions call ck_fun()
237                             ops_with_check('ck_exec'),
238                             ops_with_check('ck_glob'),
239                             ops_with_check('ck_index'),
240                             ops_with_check('ck_join'),
241                             ops_with_check('ck_lfun'),
242                             ops_with_check('ck_open'),
243                             ops_with_check('ck_select'),
244                             ops_with_check('ck_stringify'),
245                             ops_with_check('ck_tell'),
246                             ops_with_check('ck_trunc'),
247                             ;
248
249
250     for (sort keys %args1) {
251         addbits($_, '0..0' => {
252                 mask_def  => 'OPpARG1_MASK',
253                 label     => '-',
254             }
255         );
256     }
257
258     for (sort keys %args2) {
259         addbits($_, '0..1' => {
260                 mask_def  => 'OPpARG2_MASK',
261                 label     => '-',
262             }
263         );
264     }
265
266     for (sort keys %args3) {
267         addbits($_, '0..2' => {
268                 mask_def  => 'OPpARG3_MASK',
269                 label     => '-',
270             }
271         );
272     }
273
274     for (sort keys %args4) {
275         addbits($_, '0..3' => {
276                 mask_def  => 'OPpARG4_MASK',
277                 label     => '-',
278             }
279         );
280     }
281 }
282
283
284
285 # if NATIVE_HINTS is defined, op_private on cops holds the top 8 bits
286 # of PL_hints, although only bits 6 & 7 are officially used for that
287 # purpose (the rest ought to be masked off). Bit 5 is set separately
288
289 for (qw(nextstate dbstate)) {
290     addbits($_,
291         5 => qw(OPpHUSH_VMSISH          HUSH),
292     );
293 }
294
295
296 # op is in local context, or pad variable is being introduced, e.g.
297 #   local $h{foo}
298 #   my $x
299
300 addbits($_, 7 => qw(OPpLVAL_INTRO LVINTRO))
301     for qw(gvsv rv2sv rv2hv rv2gv rv2av aelem helem aslice split
302            hslice delete padsv padav padhv enteriter entersub padrange
303            pushmark cond_expr refassign lvref lvrefslice lvavref multideref),
304            'list', # this gets set in my_attrs() for some reason
305            ;
306
307
308
309 # TARGLEX
310 #
311 # in constructs like my $x; ...; $x = $a + $b,
312 # the sassign is optimised away and OPpTARGET_MY is set on the add op
313 #
314 # Note that OPpTARGET_MY is mainly used at compile-time. At run time,
315 # the pp function just updates the SV pointed to by op_targ, and doesn't
316 # care whether that's a PADTMP or a lexical var.
317
318 # Some comments about when its safe to use T/OPpTARGET_MY.
319 #
320 # Safe to set if the ppcode uses:
321 #       tryAMAGICbin, tryAMAGICun, SETn, SETi, SETu, PUSHn, PUSHTARG, SETTARG,
322 #       SETs(TARG), XPUSHn, XPUSHu,
323 # but make sure set-magic is invoked separately for SETs(TARG) (or change
324 # it to SETTARG).
325 #
326 # Unsafe to set if the ppcode uses dTARG or [X]RETPUSH[YES|NO|UNDEF]
327 #
328 # Only the code paths that handle scalar rvalue context matter.  If dTARG
329 # or RETPUSHNO occurs only in list or lvalue paths, T is safe.
330 #
331 # lt and friends do SETs (including ncmp, but not scmp or i_ncmp)
332 #
333 # Additional mode of failure: the opcode can modify TARG before it "used"
334 # all the arguments (or may call an external function which does the same).
335 # If the target coincides with one of the arguments ==> kaboom.
336 #
337 # pp.c  pos substr each not OK (RETPUSHUNDEF)
338 #       ref not OK (RETPUSHNO)
339 #       trans not OK (target is used for lhs, not retval)
340 #       ucfirst etc not OK: TMP arg processed inplace
341 #       quotemeta not OK (unsafe when TARG == arg)
342 #       pack - unknown whether it is safe
343 #       sprintf: is calling do_sprintf(TARG,...) which can act on TARG
344 #         before other args are processed.
345 #
346 #       Suspicious wrt "additional mode of failure" (and only it):
347 #       schop, chop, postinc/dec, bit_and etc, negate, complement.
348 #
349 #       Also suspicious: 4-arg substr, sprintf, uc/lc (POK_only), reverse, pack.
350 #
351 #       substr/vec: doing TAINT_off()???
352 #
353 # pp_hot.c
354 #       readline - unknown whether it is safe
355 #       match subst not OK (dTARG)
356 #       grepwhile not OK (not always setting)
357 #       join not OK (unsafe when TARG == arg)
358 #
359 #       concat - pp_concat special-cases TARG==arg to avoid
360 #               "additional mode of failure"
361 #
362 # pp_ctl.c
363 #       mapwhile flip caller not OK (not always setting)
364 #
365 # pp_sys.c
366 #       backtick glob warn die not OK (not always setting)
367 #       warn not OK (RETPUSHYES)
368 #       open fileno getc sysread syswrite ioctl accept shutdown
369 #        ftsize(etc) readlink telldir fork alarm getlogin not OK (RETPUSHUNDEF)
370 #       umask select not OK (XPUSHs(&PL_sv_undef);)
371 #       fileno getc sysread syswrite tell not OK (meth("FILENO" "GETC"))
372 #       sselect shm* sem* msg* syscall - unknown whether they are safe
373 #       gmtime not OK (list context)
374 #
375 #       Suspicious wrt "additional mode of failure": warn, die, select.
376
377
378 addbits($_, 4 => qw(OPpTARGET_MY TARGMY))
379     for ops_with_flag('T'),
380 ;
381
382
383
384
385
386 # op_targ carries a refcount
387 addbits($_, 6 => qw(OPpREFCOUNTED REFC))
388     for qw(leave leavesub leavesublv leavewrite leaveeval);
389
390
391
392 # Do not copy return value
393 addbits($_, 7 => qw(OPpLVALUE LV)) for qw(leave leaveloop);
394
395
396
397 # autovivify: Want ref to something
398 for (qw(rv2gv rv2sv padsv aelem helem entersub)) {
399     addbits($_, '4..5' => {
400                 mask_def  => 'OPpDEREF',
401                 enum => [ qw(
402                             1   OPpDEREF_AV   DREFAV
403                             2   OPpDEREF_HV   DREFHV
404                             3   OPpDEREF_SV   DREFSV
405                         )],
406             }
407     );
408 }
409
410
411
412 # Defer creation of array/hash elem
413 addbits($_, 6 => qw(OPpLVAL_DEFER LVDEFER)) for qw(aelem helem multideref);
414
415
416
417 addbits($_, 2 => qw(OPpSLICEWARNING SLICEWARN)) # warn about @hash{$scalar}
418     for qw(rv2hv rv2av padav padhv hslice aslice);
419
420
421
422 # XXX Concise seemed to think that OPpOUR_INTRO is used in rv2gv too,
423 # but I can't see it - DAPM
424 addbits($_, 6 => qw(OPpOUR_INTRO OURINTR)) # Variable was in an our()
425     for qw(gvsv rv2sv rv2av rv2hv enteriter split);
426
427
428
429 # We might be an lvalue to return
430 # 'values' doesn't actually use this bit, but we reserve it here as
431 # pp_values may call Perl_do_kv() which is shared among several ops which
432 # do.
433
434 addbits($_, 3 => qw(OPpMAYBE_LVSUB LVSUB))
435     for qw(aassign rv2av rv2gv rv2hv padav padhv aelem helem aslice hslice
436            av2arylen keys akeys avhvswitch kvaslice kvhslice substr pos vec
437            multideref values);
438
439
440
441 for (qw(rv2hv padhv ref)) {
442     addbits($_,                           # e.g. %hash in (%hash || $foo) ...
443         4 => qw(OPpMAYBE_TRUEBOOL BOOL?), # but cx not known till run time
444         5 => qw(OPpTRUEBOOL       BOOL),
445     );
446 }
447 for (qw(grepwhile index length padav pos rindex rv2av subst)) {
448     addbits($_,
449         5 => qw(OPpTRUEBOOL       BOOL),  # if (@a) {...}
450     );
451 }
452
453
454 addbits($_, 1 => qw(OPpHINT_STRICT_REFS STRICT))
455     for qw(rv2sv rv2av rv2hv rv2gv multideref);
456
457
458
459 # Treat caller(1) as caller(2)
460 addbits($_, 7 => qw(OPpOFFBYONE  +1)) for qw(caller wantarray runcv);
461
462
463
464 # label is in UTF8 */
465 addbits($_, 7 => qw(OPpPV_IS_UTF8 UTF)) for qw(last redo next goto dump);
466
467
468
469 # ====================================================================
470 #
471 # OP-SPECIFIC OPpFOO_* flags:
472 #
473 # where FOO is typically the name of an op, and the flag is used by a
474 # single op (or maybe by a few closely related ops).
475
476
477
478 # note that for refassign, this bit can mean either OPpPAD_STATE or
479 # OPpOUR_INTRO depending on the type of the LH child, .e.g.
480 #   \our   $foo = ...
481 #   \state $foo = ...
482
483 addbits($_, 6 => qw(OPpPAD_STATE STATE))  for qw(padav padhv padsv lvavref
484                                                  lvref refassign pushmark);
485
486 # NB: both sassign and aassign use the 'OPpASSIGN' naming convention
487 # for their private flags
488
489 # there *may* be common scalar items on both sides of a list assign:
490 # run-time checking will be needed.
491 addbits('aassign', 6 => qw(OPpASSIGN_COMMON_SCALAR COM_SCALAR));
492 #
493 # as above, but it's possible to check for non-commonality with just
494 # a SvREFCNT(lhs) == 1 test for each lhs element
495 addbits('aassign', 5 => qw(OPpASSIGN_COMMON_RC1 COM_RC1));
496
497 # run-time checking is required for an aggregate on the LHS
498 addbits('aassign', 4 => qw(OPpASSIGN_COMMON_AGG COM_AGG));
499
500 addbits('aassign', 2 => qw(OPpASSIGN_TRUEBOOL BOOL));  # if (@a = (...)) {...}
501
502
503 # NB: both sassign and aassign use the 'OPpASSIGN' naming convention
504 # for their private flags
505
506 addbits('sassign',
507     6 => qw(OPpASSIGN_BACKWARDS BKWARD), # Left & right switched
508     7 => qw(OPpASSIGN_CV_TO_GV  CV2GV),  # Possible optimisation for constants
509 );
510
511
512
513 for (qw(trans transr)) {
514     addbits($_,
515         0 => qw(OPpTRANS_FROM_UTF   <UTF),
516         1 => qw(OPpTRANS_TO_UTF     >UTF),
517         2 => qw(OPpTRANS_IDENTICAL  IDENT),   # right side is same as left
518         3 => qw(OPpTRANS_SQUASH     SQUASH),
519         # 4 is used for OPpTARGET_MY
520         5 => qw(OPpTRANS_COMPLEMENT COMPL),
521         6 => qw(OPpTRANS_GROWS      GROWS),
522         7 => qw(OPpTRANS_DELETE     DEL),
523     );
524 }
525
526
527
528 addbits('repeat', 6 => qw(OPpREPEAT_DOLIST DOLIST)); # List replication
529
530
531
532 # OP_ENTERSUB and OP_RV2CV flags
533 #
534 # Flags are set on entersub and rv2cv in three phases:
535 #   parser  - the parser passes the flag to the op constructor
536 #   check   - the check routine called by the op constructor sets the flag
537 #   context - application of scalar/ref/lvalue context applies the flag
538 #
539 # In the third stage, an entersub op might turn into an rv2cv op (undef &foo,
540 # \&foo, lock &foo, exists &foo, defined &foo).  The two places where that
541 # happens (op_lvalue_flags and doref in op.c) need to make sure the flags do
542 # not conflict, since some flags with different meanings overlap between
543 # the two ops.  Flags applied in the context phase are only set when there
544 # is no conversion of op type.
545 #
546 #   bit  entersub flag       phase   rv2cv flag             phase
547 #   ---  -------------       -----   ----------             -----
548 #     0  OPpENTERSUB_INARGS  context
549 #     1  HINT_STRICT_REFS    check   HINT_STRICT_REFS       check
550 #     2  OPpENTERSUB_HASTARG checki  OPpENTERSUB_HASTARG
551 #     3  OPpENTERSUB_AMPER   check   OPpENTERSUB_AMPER      parser
552 #     4  OPpDEREF_AV         context
553 #     5  OPpDEREF_HV         context OPpMAY_RETURN_CONSTANT parser/context
554 #     6  OPpENTERSUB_DB      check   OPpENTERSUB_DB
555 #     7  OPpLVAL_INTRO       context OPpENTERSUB_NOPAREN    parser
556
557 # NB: OPpHINT_STRICT_REFS must equal HINT_STRICT_REFS
558
559 addbits('entersub',
560     0      => qw(OPpENTERSUB_INARGS   INARGS), # Lval used as arg to a sub
561     1      => qw(OPpHINT_STRICT_REFS  STRICT), # 'use strict' in scope
562     2      => qw(OPpENTERSUB_HASTARG  TARG  ), # Called from OP tree
563     3      => qw(OPpENTERSUB_AMPER    AMPER),  # Used & form to call
564     # 4..5 => OPpDEREF,      already defined above
565     6      => qw(OPpENTERSUB_DB       DBG   ), # Debug subroutine
566     # 7    => OPpLVAL_INTRO, already defined above
567 );
568
569 # note that some of these flags are just left-over from when an entersub
570 # is converted into an rv2cv, and could probably be cleared/re-assigned
571
572 addbits('rv2cv',
573     1 => qw(OPpHINT_STRICT_REFS    STRICT), # 'use strict' in scope
574     2 => qw(OPpENTERSUB_HASTARG    TARG  ), # If const sub, return the const
575     3 => qw(OPpENTERSUB_AMPER      AMPER ), # Used & form to call
576
577     5 => qw(OPpMAY_RETURN_CONSTANT CONST ),
578     6 => qw(OPpENTERSUB_DB         DBG   ), # Debug subroutine
579     7 => qw(OPpENTERSUB_NOPAREN    NO()  ), # bare sub call (without parens)
580 );
581
582
583
584 #foo() called before sub foo was parsed */
585 addbits('gv', 5 => qw(OPpEARLY_CV EARLYCV));
586
587
588
589 # 1st arg is replacement string */
590 addbits('substr', 4 => qw(OPpSUBSTR_REPL_FIRST REPL1ST));
591
592
593
594 addbits('padrange',
595     # bits 0..6 hold target range
596     '0..6' =>  {
597             label         => 'range',
598             mask_def      => 'OPpPADRANGE_COUNTMASK',
599             bitcount_def  => 'OPpPADRANGE_COUNTSHIFT',
600           }
601      # 7    => OPpLVAL_INTRO, already defined above
602 );
603
604
605
606 for (qw(aelemfast aelemfast_lex)) {
607     addbits($_,
608         '0..7' =>  {
609                 label     => 'key',
610               }
611     );
612 }
613
614
615
616 addbits('rv2gv',
617     2 => qw(OPpDONT_INIT_GV NOINIT), # Call gv_fetchpv with GV_NOINIT
618                             # (Therefore will return whatever is currently in
619                             # the symbol table, not guaranteed to be a PVGV)
620     6 => qw(OPpALLOW_FAKE   FAKE),   # OK to return fake glob
621 );
622
623
624 # NB OPpITER_REVERSED must always be bit 1: see pp_iter()
625
626 addbits('enteriter',
627                     1 => qw(OPpITER_REVERSED REVERSED),# for (reverse ...)
628                     3 => qw(OPpITER_DEF      DEF),     # 'for $_'
629 );
630 addbits('iter',     1 => qw(OPpITER_REVERSED REVERSED));
631
632
633
634 addbits('const',
635     1 => qw(OPpCONST_NOVER        NOVER),   # no 6;
636     2 => qw(OPpCONST_SHORTCIRCUIT SHORT),   # e.g. the constant 5 in (5 || foo)
637     3 => qw(OPpCONST_STRICT       STRICT),  # bareword subject to strict 'subs'
638     4 => qw(OPpCONST_ENTERED      ENTERED), # Has been entered as symbol
639     6 => qw(OPpCONST_BARE         BARE),    # Was a bare word (filehandle?)
640 );
641
642
643
644 # Range arg potentially a line num. */
645 addbits($_, 6 => qw(OPpFLIP_LINENUM LINENUM)) for qw(flip flop);
646
647
648
649 # Guessed that pushmark was needed. */
650 addbits('list', 6 => qw(OPpLIST_GUESSED GUESSED));
651
652
653
654 addbits('delete',
655     5 => qw(OPpKVSLICE KVSLICE), # Operating on a list of key/value pairs
656     6 => qw(OPpSLICE   SLICE  ), # Operating on a list of keys
657    #7 => OPpLVAL_INTRO, already defined above
658 );
659
660
661
662 # Checking for &sub, not {} or [].
663 addbits('exists', 6 => qw(OPpEXISTS_SUB SUB));
664
665
666
667 addbits('sort',
668     0 => qw(OPpSORT_NUMERIC  NUM    ), # Optimized away { $a <=> $b }
669     1 => qw(OPpSORT_INTEGER  INT    ), # Ditto while under "use integer"
670     2 => qw(OPpSORT_REVERSE  REV    ), # Reversed sort
671     3 => qw(OPpSORT_INPLACE  INPLACE), # sort in-place; eg @a = sort @a
672     4 => qw(OPpSORT_DESCEND  DESC   ), # Descending sort
673     5 => qw(OPpSORT_QSORT    QSORT  ), # Use quicksort (not mergesort)
674     6 => qw(OPpSORT_STABLE   STABLE ), # Use a stable algorithm
675 );
676
677
678
679 # reverse in-place (@a = reverse @a) */
680 addbits('reverse', 3 => qw(OPpREVERSE_INPLACE  INPLACE));
681
682
683
684 for (qw(open backtick)) {
685     addbits($_,
686         4 => qw(OPpOPEN_IN_RAW    INBIN ), # binmode(F,":raw")  on input  fh
687         5 => qw(OPpOPEN_IN_CRLF   INCR  ), # binmode(F,":crlf") on input  fh
688         6 => qw(OPpOPEN_OUT_RAW   OUTBIN), # binmode(F,":raw")  on output fh
689         7 => qw(OPpOPEN_OUT_CRLF  OUTCR ), # binmode(F,":crlf") on output fh
690     );
691 }
692
693
694
695 # The various OPpFT* filetest ops
696
697 # "use filetest 'access'" is in scope:
698 # this flag is set only on a subset of the FT* ops
699 addbits($_, 1 => qw(OPpFT_ACCESS FTACCESS)) for ops_with_arg(0, 'F-+');
700
701 # all OPpFT* ops except stat and lstat
702 for (grep { $_ !~ /^l?stat$/ } ops_with_flag('-')) {
703     addbits($_,
704         2 => qw(OPpFT_STACKED  FTSTACKED ),  # stacked filetest,
705                                              #    e.g. "-f" in "-f -x $foo"
706         3 => qw(OPpFT_STACKING FTSTACKING),  # stacking filetest.
707                                              #    e.g. "-x" in "-f -x $foo"
708         4 => qw(OPpFT_AFTER_t  FTAFTERt  ),  # previous op was -t
709     );
710 }
711
712
713
714 addbits('entereval',
715     1 => qw(OPpEVAL_HAS_HH       HAS_HH ), # Does it have a copy of %^H ?
716     2 => qw(OPpEVAL_UNICODE      UNI    ),
717     3 => qw(OPpEVAL_BYTES        BYTES  ),
718     4 => qw(OPpEVAL_COPHH        COPHH  ), # Construct %^H from COP hints
719     5 => qw(OPpEVAL_RE_REPARSING REPARSE), # eval_sv(..., G_RE_REPARSING)
720 );
721
722
723
724 # These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE.
725 # See pp.c:S_rv2gv. */
726 addbits('coreargs',
727     0 => qw(OPpCOREARGS_DEREF1    DEREF1), # Arg 1 is a handle constructor
728     1 => qw(OPpCOREARGS_DEREF2    DEREF2), # Arg 2 is a handle constructor
729    #2 reserved for OPpDONT_INIT_GV in rv2gv
730    #4 reserved for OPpALLOW_FAKE   in rv2gv
731     6 => qw(OPpCOREARGS_SCALARMOD $MOD  ), # \$ rather than \[$@%*]
732     7 => qw(OPpCOREARGS_PUSHMARK  MARK  ), # Call pp_pushmark
733 );
734
735
736
737 addbits('split',
738     # @a = split() has been replaced with  split() where split itself
739     # does the array assign
740     4 => qw(OPpSPLIT_ASSIGN ASSIGN), 
741     3 => qw(OPpSPLIT_LEX LEX),  # the OPpSPLIT_ASSIGN is a lexical array
742     2 => qw(OPpSPLIT_IMPLIM IMPLIM), # implicit limit
743 );
744
745
746 addbits($_,
747     2 => qw(OPpLVREF_ELEM ELEM   ),
748     3 => qw(OPpLVREF_ITER ITER   ),
749 '4..5'=> {
750            mask_def => 'OPpLVREF_TYPE',
751            enum     => [ qw(
752                              0   OPpLVREF_SV   SV
753                              1   OPpLVREF_AV   AV
754                              2   OPpLVREF_HV   HV
755                              3   OPpLVREF_CV   CV
756                          )],
757          },
758    #6 => qw(OPpPAD_STATE STATE),
759    #7 => qw(OPpLVAL_INTRO LVINTRO),
760 ) for 'refassign', 'lvref';
761
762
763
764 addbits('multideref',
765     4 => qw(OPpMULTIDEREF_EXISTS EXISTS), # deref is actually exists
766     5 => qw(OPpMULTIDEREF_DELETE DELETE), # deref is actually delete
767 );
768
769
770
771 addbits('avhvswitch',
772     '0..1' => {
773                    mask_def  => 'OPpAVHVSWITCH_MASK',
774                    label     => 'offset',
775     }
776 );
777
778
779 addbits('argelem',
780    '1..2' =>  {
781                    mask_def  => 'OPpARGELEM_MASK',
782                    enum => [ qw(
783                                0   OPpARGELEM_SV   SV
784                                1   OPpARGELEM_AV   AV
785                                2   OPpARGELEM_HV   HV
786                            )],
787                },
788 );
789
790
791 # rv2hv and padhv in void/scalar context implementing 'keys %h'
792 # directly, without a following OP_KEYS
793
794 addbits('padhv',
795     0 => qw(OPpPADHV_ISKEYS KEYS),
796 );
797 addbits('rv2hv',
798     0 => qw(OPpRV2HV_ISKEYS KEYS),
799 );
800
801 # In conjunction with OPpTRUEBOOL, indicates that the test should be
802 # inverted. This allows both (index() == -1) and (index() != -1)
803 # to optimise away the const and eq/ne
804
805 for (qw(index rindex)) {
806     addbits($_, 6 => qw(OPpINDEX_BOOLNEG NEG));
807 }
808
809
810
811 1;
812
813 # ex: set ts=8 sts=4 sw=4 et: