Commit | Line | Data |
---|---|---|
f3574cc6 DM |
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 | ||
c10dbd97 DM |
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 | |
f3574cc6 DM |
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), | |
956f044d | 38 | 6 => qw(OPpLVAL_DEFER LVDEFER), |
9e209402 | 39 | '4..5' => { |
f3574cc6 DM |
40 | mask_def => 'OPpDEREF', |
41 | enum => [ qw( | |
42 | 1 OPpDEREF_AV DREFAV | |
43 | 2 OPpDEREF_HV DREFHV | |
44 | 3 OPpDEREF_SV DREFSV | |
45 | )], | |
46 | }, | |
f3574cc6 DM |
47 | ); |
48 | ||
956f044d | 49 | Here for the op C<aelem>, bits 6 and 7 (bits are numbered 0..7) are |
f3574cc6 DM |
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 | ||
c10dbd97 DM |
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). | |
f3574cc6 DM |
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 | ||
c10dbd97 | 88 | which 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 | ||
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 | |
c10dbd97 DM |
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 | |
f3574cc6 DM |
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 | ||
748f2c65 DM |
201 | $args0{$_} = 1 for qw(entersub avhvswitch |
202 | rv2hv); # UNOPs that usurp bit 0 | |
f3574cc6 DM |
203 | |
204 | $args1{$_} = 1 for ( | |
205 | qw(reverse), # ck_fun(), but most bits stolen | |
fb0c7c3c FC |
206 | qw(mapstart grepstart), # set in ck_fun, but |
207 | # cleared in ck_grep, | |
208 | # unless there is an error | |
f3574cc6 DM |
209 | grep !$maxarg{$_} && !$args0{$_}, |
210 | ops_with_flag('1'), # UNOP | |
2f7c6295 | 211 | ops_with_flag('+'), # UNOP_AUX |
f3574cc6 DM |
212 | ops_with_flag('%'), # BASEOP/UNOP |
213 | ops_with_flag('|'), # LOGOP | |
214 | ops_with_flag('-'), # FILESTATOP | |
215 | ops_with_flag('}'), # LOOPEXOP | |
b46e009d | 216 | ops_with_flag('.'), # METHOP |
f3574cc6 DM |
217 | ); |
218 | ||
219 | $args2{$_} = 1 for ( | |
220 | qw(vec), | |
221 | grep !$maxarg{$_} && !$args0{$_} && !$args1{$_}, | |
222 | ops_with_flag('2'), # BINOP | |
f3574cc6 DM |
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'), | |
73f4c4fe | 244 | ops_with_check('ck_stringify'), |
f3574cc6 DM |
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), | |
f3574cc6 DM |
292 | ); |
293 | } | |
294 | ||
295 | ||
4e0538d9 DM |
296 | # op is in local context, or pad variable is being introduced, e.g. |
297 | # local $h{foo} | |
298 | # my $x | |
f3574cc6 DM |
299 | |
300 | addbits($_, 7 => qw(OPpLVAL_INTRO LVINTRO)) | |
692044df | 301 | for qw(gvsv rv2sv rv2hv rv2gv rv2av aelem helem aslice split |
f3574cc6 | 302 | hslice delete padsv padav padhv enteriter entersub padrange |
fedf30e1 | 303 | pushmark cond_expr refassign lvref lvrefslice lvavref multideref), |
f3574cc6 DM |
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 | |
b4941db2 DM |
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. | |
f3574cc6 | 317 | |
16a6edfa DM |
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, | |
e83bf98c FC |
323 | # but make sure set-magic is invoked separately for SETs(TARG) (or change |
324 | # it to SETTARG). | |
16a6edfa DM |
325 | # |
326 | # Unsafe to set if the ppcode uses dTARG or [X]RETPUSH[YES|NO|UNDEF] | |
327 | # | |
e83bf98c FC |
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 | # | |
d1455c67 | 331 | # lt and friends do SETs (including ncmp, but not scmp or i_ncmp) |
16a6edfa DM |
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) | |
16a6edfa | 338 | # ref not OK (RETPUSHNO) |
b0da25f0 | 339 | # trans not OK (target is used for lhs, not retval) |
16a6edfa DM |
340 | # ucfirst etc not OK: TMP arg processed inplace |
341 | # quotemeta not OK (unsafe when TARG == arg) | |
d8cdf573 | 342 | # pack - unknown whether it is safe |
16a6edfa DM |
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 | # | |
8ecc2ae2 FC |
359 | # concat - pp_concat special-cases TARG==arg to avoid |
360 | # "additional mode of failure" | |
16a6edfa DM |
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 | ||
f3574cc6 DM |
378 | addbits($_, 4 => qw(OPpTARGET_MY TARGMY)) |
379 | for ops_with_flag('T'), | |
f3574cc6 DM |
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 | ||
f3574cc6 DM |
397 | # autovivify: Want ref to something |
398 | for (qw(rv2gv rv2sv padsv aelem helem entersub)) { | |
9e209402 | 399 | addbits($_, '4..5' => { |
f3574cc6 DM |
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 | |
fedf30e1 | 413 | addbits($_, 6 => qw(OPpLVAL_DEFER LVDEFER)) for qw(aelem helem multideref); |
f3574cc6 DM |
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 | |
9e209402 | 424 | addbits($_, 6 => qw(OPpOUR_INTRO OURINTR)) # Variable was in an our() |
de183bbb | 425 | for qw(gvsv rv2sv rv2av rv2hv enteriter split); |
f3574cc6 DM |
426 | |
427 | ||
428 | ||
429 | # We might be an lvalue to return | |
4fa080db DM |
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 | ||
f3574cc6 DM |
434 | addbits($_, 3 => qw(OPpMAYBE_LVSUB LVSUB)) |
435 | for qw(aassign rv2av rv2gv rv2hv padav padhv aelem helem aslice hslice | |
cd642408 | 436 | av2arylen keys akeys avhvswitch kvaslice kvhslice substr pos vec |
4fa080db | 437 | multideref values); |
f3574cc6 DM |
438 | |
439 | ||
440 | ||
ba75e9a4 | 441 | for (qw(rv2hv padhv ref)) { |
f3574cc6 | 442 | addbits($_, # e.g. %hash in (%hash || $foo) ... |
7be75ccf DM |
443 | 4 => qw(OPpMAYBE_TRUEBOOL BOOL?), # but cx not known till run time |
444 | 5 => qw(OPpTRUEBOOL BOOL), | |
445 | ); | |
446 | } | |
7e8d786b | 447 | for (qw(grepwhile index length padav pos rindex rv2av subst)) { |
7be75ccf DM |
448 | addbits($_, |
449 | 5 => qw(OPpTRUEBOOL BOOL), # if (@a) {...} | |
f3574cc6 DM |
450 | ); |
451 | } | |
f3574cc6 DM |
452 | |
453 | ||
fedf30e1 DM |
454 | addbits($_, 1 => qw(OPpHINT_STRICT_REFS STRICT)) |
455 | for qw(rv2sv rv2av rv2hv rv2gv multideref); | |
f3574cc6 DM |
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 | ||
b13702a2 DM |
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 | ||
9e209402 | 483 | addbits($_, 6 => qw(OPpPAD_STATE STATE)) for qw(padav padhv padsv lvavref |
3ad7d304 | 484 | lvref refassign pushmark); |
f3574cc6 | 485 | |
a5f48505 DM |
486 | # NB: both sassign and aassign use the 'OPpASSIGN' naming convention |
487 | # for their private flags | |
f3574cc6 | 488 | |
a5f48505 DM |
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)); | |
f3574cc6 | 499 | |
7b394f12 | 500 | addbits('aassign', 2 => qw(OPpASSIGN_TRUEBOOL BOOL)); # if (@a = (...)) {...} |
f3574cc6 DM |
501 | |
502 | ||
a5f48505 DM |
503 | # NB: both sassign and aassign use the 'OPpASSIGN' naming convention |
504 | # for their private flags | |
f3574cc6 DM |
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 | |
62ead80f | 550 | # 2 OPpENTERSUB_HASTARG checki OPpENTERSUB_HASTARG |
f3574cc6 | 551 | # 3 OPpENTERSUB_AMPER check OPpENTERSUB_AMPER parser |
9e209402 FC |
552 | # 4 OPpDEREF_AV context |
553 | # 5 OPpDEREF_HV context OPpMAY_RETURN_CONSTANT parser/context | |
554 | # 6 OPpENTERSUB_DB check OPpENTERSUB_DB | |
f3574cc6 DM |
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 | |
c486bd5c | 561 | 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope |
f3574cc6 DM |
562 | 2 => qw(OPpENTERSUB_HASTARG TARG ), # Called from OP tree |
563 | 3 => qw(OPpENTERSUB_AMPER AMPER), # Used & form to call | |
9e209402 FC |
564 | # 4..5 => OPpDEREF, already defined above |
565 | 6 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine | |
f3574cc6 DM |
566 | # 7 => OPpLVAL_INTRO, already defined above |
567 | ); | |
f3574cc6 | 568 | |
62ead80f DM |
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 | |
f3574cc6 DM |
571 | |
572 | addbits('rv2cv', | |
62ead80f DM |
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 | |
62ead80f | 576 | |
9e209402 FC |
577 | 5 => qw(OPpMAY_RETURN_CONSTANT CONST ), |
578 | 6 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine | |
62ead80f | 579 | 7 => qw(OPpENTERSUB_NOPAREN NO() ), # bare sub call (without parens) |
f3574cc6 DM |
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' => { | |
e9fb18e4 | 597 | label => 'range', |
f3574cc6 DM |
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' => { | |
e9fb18e4 | 609 | label => 'key', |
f3574cc6 DM |
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) | |
9e209402 | 620 | 6 => qw(OPpALLOW_FAKE FAKE), # OK to return fake glob |
f3574cc6 DM |
621 | ); |
622 | ||
623 | ||
93661e56 | 624 | # NB OPpITER_REVERSED must always be bit 1: see pp_iter() |
f3574cc6 DM |
625 | |
626 | addbits('enteriter', | |
93661e56 | 627 | 1 => qw(OPpITER_REVERSED REVERSED),# for (reverse ...) |
ce036583 | 628 | 3 => qw(OPpITER_DEF DEF), # 'for $_' |
f3574cc6 | 629 | ); |
93661e56 | 630 | addbits('iter', 1 => qw(OPpITER_REVERSED REVERSED)); |
f3574cc6 DM |
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 | ||
cc0776d6 DIM |
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 | ); | |
f3574cc6 DM |
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 | |
afe59f35 | 675 | 7 => qw(OPpSORT_UNSTABLE UNSTABLE),# Use an unstable algorithm |
f3574cc6 DM |
676 | ); |
677 | ||
678 | ||
679 | ||
680 | # reverse in-place (@a = reverse @a) */ | |
681 | addbits('reverse', 3 => qw(OPpREVERSE_INPLACE INPLACE)); | |
682 | ||
683 | ||
684 | ||
685 | for (qw(open backtick)) { | |
686 | addbits($_, | |
687 | 4 => qw(OPpOPEN_IN_RAW INBIN ), # binmode(F,":raw") on input fh | |
688 | 5 => qw(OPpOPEN_IN_CRLF INCR ), # binmode(F,":crlf") on input fh | |
689 | 6 => qw(OPpOPEN_OUT_RAW OUTBIN), # binmode(F,":raw") on output fh | |
690 | 7 => qw(OPpOPEN_OUT_CRLF OUTCR ), # binmode(F,":crlf") on output fh | |
691 | ); | |
692 | } | |
693 | ||
694 | ||
695 | ||
696 | # The various OPpFT* filetest ops | |
697 | ||
698 | # "use filetest 'access'" is in scope: | |
699 | # this flag is set only on a subset of the FT* ops | |
700 | addbits($_, 1 => qw(OPpFT_ACCESS FTACCESS)) for ops_with_arg(0, 'F-+'); | |
701 | ||
702 | # all OPpFT* ops except stat and lstat | |
703 | for (grep { $_ !~ /^l?stat$/ } ops_with_flag('-')) { | |
704 | addbits($_, | |
705 | 2 => qw(OPpFT_STACKED FTSTACKED ), # stacked filetest, | |
706 | # e.g. "-f" in "-f -x $foo" | |
707 | 3 => qw(OPpFT_STACKING FTSTACKING), # stacking filetest. | |
708 | # e.g. "-x" in "-f -x $foo" | |
709 | 4 => qw(OPpFT_AFTER_t FTAFTERt ), # previous op was -t | |
710 | ); | |
711 | } | |
712 | ||
713 | ||
714 | ||
f3574cc6 DM |
715 | addbits('entereval', |
716 | 1 => qw(OPpEVAL_HAS_HH HAS_HH ), # Does it have a copy of %^H ? | |
717 | 2 => qw(OPpEVAL_UNICODE UNI ), | |
718 | 3 => qw(OPpEVAL_BYTES BYTES ), | |
719 | 4 => qw(OPpEVAL_COPHH COPHH ), # Construct %^H from COP hints | |
c486bd5c | 720 | 5 => qw(OPpEVAL_RE_REPARSING REPARSE), # eval_sv(..., G_RE_REPARSING) |
f3574cc6 DM |
721 | ); |
722 | ||
723 | ||
724 | ||
725 | # These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE. | |
726 | # See pp.c:S_rv2gv. */ | |
727 | addbits('coreargs', | |
728 | 0 => qw(OPpCOREARGS_DEREF1 DEREF1), # Arg 1 is a handle constructor | |
729 | 1 => qw(OPpCOREARGS_DEREF2 DEREF2), # Arg 2 is a handle constructor | |
730 | #2 reserved for OPpDONT_INIT_GV in rv2gv | |
731 | #4 reserved for OPpALLOW_FAKE in rv2gv | |
732 | 6 => qw(OPpCOREARGS_SCALARMOD $MOD ), # \$ rather than \[$@%*] | |
733 | 7 => qw(OPpCOREARGS_PUSHMARK MARK ), # Call pp_pushmark | |
734 | ); | |
735 | ||
736 | ||
737 | ||
5012eebe | 738 | addbits('split', |
5012eebe DM |
739 | # @a = split() has been replaced with split() where split itself |
740 | # does the array assign | |
741 | 4 => qw(OPpSPLIT_ASSIGN ASSIGN), | |
742 | 3 => qw(OPpSPLIT_LEX LEX), # the OPpSPLIT_ASSIGN is a lexical array | |
692044df | 743 | 2 => qw(OPpSPLIT_IMPLIM IMPLIM), # implicit limit |
5012eebe | 744 | ); |
6102323a FC |
745 | |
746 | ||
747 | addbits($_, | |
748 | 2 => qw(OPpLVREF_ELEM ELEM ), | |
5a36b2c0 | 749 | 3 => qw(OPpLVREF_ITER ITER ), |
9e209402 | 750 | '4..5'=> { |
c2380ea1 FC |
751 | mask_def => 'OPpLVREF_TYPE', |
752 | enum => [ qw( | |
753 | 0 OPpLVREF_SV SV | |
754 | 1 OPpLVREF_AV AV | |
755 | 2 OPpLVREF_HV HV | |
756 | 3 OPpLVREF_CV CV | |
757 | )], | |
758 | }, | |
b13702a2 | 759 | #6 => qw(OPpPAD_STATE STATE), |
6102323a FC |
760 | #7 => qw(OPpLVAL_INTRO LVINTRO), |
761 | ) for 'refassign', 'lvref'; | |
762 | ||
fedf30e1 DM |
763 | |
764 | ||
765 | addbits('multideref', | |
766 | 4 => qw(OPpMULTIDEREF_EXISTS EXISTS), # deref is actually exists | |
767 | 5 => qw(OPpMULTIDEREF_DELETE DELETE), # deref is actually delete | |
768 | ); | |
769 | ||
73665bc4 FC |
770 | |
771 | ||
e1e26374 DM |
772 | addbits('avhvswitch', |
773 | '0..1' => { | |
774 | mask_def => 'OPpAVHVSWITCH_MASK', | |
775 | label => 'offset', | |
776 | } | |
777 | ); | |
778 | ||
73665bc4 | 779 | |
4fa06845 DM |
780 | addbits('argelem', |
781 | '1..2' => { | |
782 | mask_def => 'OPpARGELEM_MASK', | |
783 | enum => [ qw( | |
784 | 0 OPpARGELEM_SV SV | |
785 | 1 OPpARGELEM_AV AV | |
786 | 2 OPpARGELEM_HV HV | |
787 | )], | |
788 | }, | |
789 | ); | |
790 | ||
791 | ||
748f2c65 DM |
792 | # rv2hv and padhv in void/scalar context implementing 'keys %h' |
793 | # directly, without a following OP_KEYS | |
794 | ||
795 | addbits('padhv', | |
796 | 0 => qw(OPpPADHV_ISKEYS KEYS), | |
797 | ); | |
798 | addbits('rv2hv', | |
799 | 0 => qw(OPpRV2HV_ISKEYS KEYS), | |
800 | ); | |
801 | ||
7e8d786b DM |
802 | # In conjunction with OPpTRUEBOOL, indicates that the test should be |
803 | # inverted. This allows both (index() == -1) and (index() != -1) | |
804 | # to optimise away the const and eq/ne | |
805 | ||
806 | for (qw(index rindex)) { | |
807 | addbits($_, 6 => qw(OPpINDEX_BOOLNEG NEG)); | |
808 | } | |
809 | ||
748f2c65 DM |
810 | |
811 | ||
f3574cc6 DM |
812 | 1; |
813 | ||
814 | # ex: set ts=8 sts=4 sw=4 et: |