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), | |
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 | ||
49 | Here for the op C<aelem>, bits 4 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 | ||
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 | ||
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 | ||
285 | for (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 | ||
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)) | |
4e0538d9 | 301 | for qw(gvsv rv2sv rv2hv rv2gv rv2av aelem helem aslice |
f3574cc6 DM |
302 | hslice delete padsv padav padhv enteriter entersub padrange |
303 | pushmark cond_expr), | |
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, | |
323 | # | |
324 | # Unsafe to set if the ppcode uses dTARG or [X]RETPUSH[YES|NO|UNDEF] | |
325 | # | |
326 | # lt and friends do SETs (including ncmp, but not scmp) | |
327 | # | |
328 | # Additional mode of failure: the opcode can modify TARG before it "used" | |
329 | # all the arguments (or may call an external function which does the same). | |
330 | # If the target coincides with one of the arguments ==> kaboom. | |
331 | # | |
332 | # pp.c pos substr each not OK (RETPUSHUNDEF) | |
333 | # substr vec also not OK due to LV to target (are they???) | |
334 | # ref not OK (RETPUSHNO) | |
335 | # trans not OK (dTARG; TARG = sv_newmortal();) | |
336 | # ucfirst etc not OK: TMP arg processed inplace | |
337 | # quotemeta not OK (unsafe when TARG == arg) | |
338 | # each repeat not OK too due to list context | |
339 | # pack split - unknown whether they are safe | |
340 | # sprintf: is calling do_sprintf(TARG,...) which can act on TARG | |
341 | # before other args are processed. | |
342 | # | |
343 | # Suspicious wrt "additional mode of failure" (and only it): | |
344 | # schop, chop, postinc/dec, bit_and etc, negate, complement. | |
345 | # | |
346 | # Also suspicious: 4-arg substr, sprintf, uc/lc (POK_only), reverse, pack. | |
347 | # | |
348 | # substr/vec: doing TAINT_off()??? | |
349 | # | |
350 | # pp_hot.c | |
351 | # readline - unknown whether it is safe | |
352 | # match subst not OK (dTARG) | |
353 | # grepwhile not OK (not always setting) | |
354 | # join not OK (unsafe when TARG == arg) | |
355 | # | |
356 | # Suspicious wrt "additional mode of failure": concat (dealt with | |
357 | # in ck_sassign()), join (same). | |
358 | # | |
359 | # pp_ctl.c | |
360 | # mapwhile flip caller not OK (not always setting) | |
361 | # | |
362 | # pp_sys.c | |
363 | # backtick glob warn die not OK (not always setting) | |
364 | # warn not OK (RETPUSHYES) | |
365 | # open fileno getc sysread syswrite ioctl accept shutdown | |
366 | # ftsize(etc) readlink telldir fork alarm getlogin not OK (RETPUSHUNDEF) | |
367 | # umask select not OK (XPUSHs(&PL_sv_undef);) | |
368 | # fileno getc sysread syswrite tell not OK (meth("FILENO" "GETC")) | |
369 | # sselect shm* sem* msg* syscall - unknown whether they are safe | |
370 | # gmtime not OK (list context) | |
371 | # | |
372 | # Suspicious wrt "additional mode of failure": warn, die, select. | |
373 | ||
374 | ||
f3574cc6 DM |
375 | addbits($_, 4 => qw(OPpTARGET_MY TARGMY)) |
376 | for ops_with_flag('T'), | |
377 | # This flag is also used to indicate matches against implicit $_, | |
378 | # where $_ is lexical; e.g. my $_; ....; /foo/ | |
379 | qw(match subst trans transr); | |
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 | # Pattern coming in on the stack | |
398 | addbits($_, 6 => qw(OPpRUNTIME RTIME)) | |
399 | for qw(match subst substcont qr pushre); | |
400 | ||
401 | ||
402 | ||
403 | # autovivify: Want ref to something | |
404 | for (qw(rv2gv rv2sv padsv aelem helem entersub)) { | |
405 | addbits($_, '5..6' => { | |
406 | mask_def => 'OPpDEREF', | |
407 | enum => [ qw( | |
408 | 1 OPpDEREF_AV DREFAV | |
409 | 2 OPpDEREF_HV DREFHV | |
410 | 3 OPpDEREF_SV DREFSV | |
411 | )], | |
412 | } | |
413 | ); | |
414 | } | |
415 | ||
416 | ||
417 | ||
418 | # Defer creation of array/hash elem | |
419 | addbits($_, 4 => qw(OPpLVAL_DEFER LVDEFER)) for qw(aelem helem); | |
420 | ||
421 | ||
422 | ||
423 | addbits($_, 2 => qw(OPpSLICEWARNING SLICEWARN)) # warn about @hash{$scalar} | |
424 | for qw(rv2hv rv2av padav padhv hslice aslice); | |
425 | ||
426 | ||
427 | ||
428 | # XXX Concise seemed to think that OPpOUR_INTRO is used in rv2gv too, | |
429 | # but I can't see it - DAPM | |
430 | addbits($_, 4 => qw(OPpOUR_INTRO OURINTR)) # Variable was in an our() | |
431 | for qw(gvsv rv2sv rv2av rv2hv enteriter); | |
432 | ||
433 | ||
434 | ||
435 | # We might be an lvalue to return | |
436 | addbits($_, 3 => qw(OPpMAYBE_LVSUB LVSUB)) | |
437 | for qw(aassign rv2av rv2gv rv2hv padav padhv aelem helem aslice hslice | |
438 | av2arylen keys rkeys kvaslice kvhslice substr pos vec); | |
439 | ||
440 | ||
441 | ||
442 | for (qw(rv2hv padhv)) { | |
443 | addbits($_, # e.g. %hash in (%hash || $foo) ... | |
444 | 5 => qw(OPpTRUEBOOL BOOL), # ... in void cxt | |
445 | 6 => qw(OPpMAYBE_TRUEBOOL BOOL?), # ... cx not known till run time | |
446 | ); | |
447 | } | |
448 | ||
449 | ||
450 | ||
c486bd5c | 451 | addbits($_, 1 => qw(OPpHINT_STRICT_REFS STRICT)) for qw(rv2sv rv2av rv2hv rv2gv); |
f3574cc6 DM |
452 | |
453 | ||
454 | ||
455 | # Treat caller(1) as caller(2) | |
456 | addbits($_, 7 => qw(OPpOFFBYONE +1)) for qw(caller wantarray runcv); | |
457 | ||
458 | ||
459 | ||
460 | # label is in UTF8 */ | |
461 | addbits($_, 7 => qw(OPpPV_IS_UTF8 UTF)) for qw(last redo next goto dump); | |
462 | ||
463 | ||
464 | ||
465 | # ==================================================================== | |
466 | # | |
467 | # OP-SPECIFIC OPpFOO_* flags: | |
468 | # | |
469 | # where FOO is typically the name of an op, and the flag is used by a | |
470 | # single op (or maybe by a few closely related ops). | |
471 | ||
472 | ||
473 | ||
474 | addbits($_, 4 => qw(OPpPAD_STATE STATE)) for qw(padav padhv padsv pushmark); | |
475 | ||
476 | ||
477 | ||
478 | addbits('aassign', 6 => qw(OPpASSIGN_COMMON COMMON)); | |
479 | ||
480 | ||
481 | ||
482 | addbits('sassign', | |
483 | 6 => qw(OPpASSIGN_BACKWARDS BKWARD), # Left & right switched | |
484 | 7 => qw(OPpASSIGN_CV_TO_GV CV2GV), # Possible optimisation for constants | |
485 | ); | |
486 | ||
487 | ||
488 | ||
489 | for (qw(trans transr)) { | |
490 | addbits($_, | |
491 | 0 => qw(OPpTRANS_FROM_UTF <UTF), | |
492 | 1 => qw(OPpTRANS_TO_UTF >UTF), | |
493 | 2 => qw(OPpTRANS_IDENTICAL IDENT), # right side is same as left | |
494 | 3 => qw(OPpTRANS_SQUASH SQUASH), | |
495 | # 4 is used for OPpTARGET_MY | |
496 | 5 => qw(OPpTRANS_COMPLEMENT COMPL), | |
497 | 6 => qw(OPpTRANS_GROWS GROWS), | |
498 | 7 => qw(OPpTRANS_DELETE DEL), | |
499 | ); | |
500 | } | |
501 | ||
502 | ||
503 | ||
504 | addbits('repeat', 6 => qw(OPpREPEAT_DOLIST DOLIST)); # List replication | |
505 | ||
506 | ||
507 | ||
508 | # OP_ENTERSUB and OP_RV2CV flags | |
509 | # | |
510 | # Flags are set on entersub and rv2cv in three phases: | |
511 | # parser - the parser passes the flag to the op constructor | |
512 | # check - the check routine called by the op constructor sets the flag | |
513 | # context - application of scalar/ref/lvalue context applies the flag | |
514 | # | |
515 | # In the third stage, an entersub op might turn into an rv2cv op (undef &foo, | |
516 | # \&foo, lock &foo, exists &foo, defined &foo). The two places where that | |
517 | # happens (op_lvalue_flags and doref in op.c) need to make sure the flags do | |
518 | # not conflict, since some flags with different meanings overlap between | |
519 | # the two ops. Flags applied in the context phase are only set when there | |
520 | # is no conversion of op type. | |
521 | # | |
522 | # bit entersub flag phase rv2cv flag phase | |
523 | # --- ------------- ----- ---------- ----- | |
524 | # 0 OPpENTERSUB_INARGS context | |
525 | # 1 HINT_STRICT_REFS check HINT_STRICT_REFS check | |
62ead80f | 526 | # 2 OPpENTERSUB_HASTARG checki OPpENTERSUB_HASTARG |
f3574cc6 | 527 | # 3 OPpENTERSUB_AMPER check OPpENTERSUB_AMPER parser |
62ead80f | 528 | # 4 OPpENTERSUB_DB check OPpENTERSUB_DB |
f3574cc6 | 529 | # 5 OPpDEREF_AV context |
0eb7ca05 | 530 | # 6 OPpDEREF_HV context OPpMAY_RETURN_CONSTANT parser/context |
f3574cc6 DM |
531 | # 7 OPpLVAL_INTRO context OPpENTERSUB_NOPAREN parser |
532 | ||
533 | # NB: OPpHINT_STRICT_REFS must equal HINT_STRICT_REFS | |
534 | ||
535 | addbits('entersub', | |
536 | 0 => qw(OPpENTERSUB_INARGS INARGS), # Lval used as arg to a sub | |
c486bd5c | 537 | 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope |
f3574cc6 DM |
538 | 2 => qw(OPpENTERSUB_HASTARG TARG ), # Called from OP tree |
539 | 3 => qw(OPpENTERSUB_AMPER AMPER), # Used & form to call | |
540 | 4 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine | |
541 | # 5..6 => OPpDEREF, already defined above | |
542 | # 7 => OPpLVAL_INTRO, already defined above | |
543 | ); | |
f3574cc6 | 544 | |
62ead80f DM |
545 | # note that some of these flags are just left-over from when an entersub |
546 | # is converted into an rv2cv, and could probably be cleared/re-assigned | |
f3574cc6 DM |
547 | |
548 | addbits('rv2cv', | |
62ead80f DM |
549 | 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope |
550 | 2 => qw(OPpENTERSUB_HASTARG TARG ), # If const sub, return the const | |
551 | 3 => qw(OPpENTERSUB_AMPER AMPER ), # Used & form to call | |
552 | 4 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine | |
553 | ||
554 | 6 => qw(OPpMAY_RETURN_CONSTANT CONST ), | |
555 | 7 => qw(OPpENTERSUB_NOPAREN NO() ), # bare sub call (without parens) | |
f3574cc6 DM |
556 | ); |
557 | ||
558 | ||
559 | ||
560 | #foo() called before sub foo was parsed */ | |
561 | addbits('gv', 5 => qw(OPpEARLY_CV EARLYCV)); | |
562 | ||
563 | ||
564 | ||
565 | # 1st arg is replacement string */ | |
566 | addbits('substr', 4 => qw(OPpSUBSTR_REPL_FIRST REPL1ST)); | |
567 | ||
568 | ||
569 | ||
570 | addbits('padrange', | |
571 | # bits 0..6 hold target range | |
572 | '0..6' => { | |
573 | label => '-', | |
574 | mask_def => 'OPpPADRANGE_COUNTMASK', | |
575 | bitcount_def => 'OPpPADRANGE_COUNTSHIFT', | |
576 | } | |
577 | # 7 => OPpLVAL_INTRO, already defined above | |
578 | ); | |
579 | ||
580 | ||
581 | ||
582 | for (qw(aelemfast aelemfast_lex)) { | |
583 | addbits($_, | |
584 | '0..7' => { | |
585 | label => '-', | |
586 | } | |
587 | ); | |
588 | } | |
589 | ||
590 | ||
591 | ||
592 | addbits('rv2gv', | |
593 | 2 => qw(OPpDONT_INIT_GV NOINIT), # Call gv_fetchpv with GV_NOINIT | |
594 | # (Therefore will return whatever is currently in | |
595 | # the symbol table, not guaranteed to be a PVGV) | |
596 | 4 => qw(OPpALLOW_FAKE FAKE), # OK to return fake glob | |
597 | ); | |
598 | ||
599 | ||
600 | ||
601 | addbits('enteriter', | |
602 | 2 => qw(OPpITER_REVERSED REVERSED),# for (reverse ...) | |
c486bd5c | 603 | 3 => qw(OPpITER_DEF DEF), # 'for $_' or 'for my $_' |
f3574cc6 DM |
604 | ); |
605 | addbits('iter', 2 => qw(OPpITER_REVERSED REVERSED)); | |
606 | ||
607 | ||
608 | ||
609 | addbits('const', | |
610 | 1 => qw(OPpCONST_NOVER NOVER), # no 6; | |
611 | 2 => qw(OPpCONST_SHORTCIRCUIT SHORT), # e.g. the constant 5 in (5 || foo) | |
612 | 3 => qw(OPpCONST_STRICT STRICT), # bareword subject to strict 'subs' | |
613 | 4 => qw(OPpCONST_ENTERED ENTERED), # Has been entered as symbol | |
614 | 6 => qw(OPpCONST_BARE BARE), # Was a bare word (filehandle?) | |
615 | ); | |
616 | ||
617 | ||
618 | ||
619 | # Range arg potentially a line num. */ | |
620 | addbits($_, 6 => qw(OPpFLIP_LINENUM LINENUM)) for qw(flip flop); | |
621 | ||
622 | ||
623 | ||
624 | # Guessed that pushmark was needed. */ | |
625 | addbits('list', 6 => qw(OPpLIST_GUESSED GUESSED)); | |
626 | ||
627 | ||
628 | ||
629 | # Operating on a list of keys | |
630 | addbits('delete', 6 => qw(OPpSLICE SLICE)); | |
631 | # also 7 => OPpLVAL_INTRO, already defined above | |
632 | ||
633 | ||
634 | ||
635 | # Checking for &sub, not {} or []. | |
636 | addbits('exists', 6 => qw(OPpEXISTS_SUB SUB)); | |
637 | ||
638 | ||
639 | ||
640 | addbits('sort', | |
641 | 0 => qw(OPpSORT_NUMERIC NUM ), # Optimized away { $a <=> $b } | |
642 | 1 => qw(OPpSORT_INTEGER INT ), # Ditto while under "use integer" | |
643 | 2 => qw(OPpSORT_REVERSE REV ), # Reversed sort | |
644 | 3 => qw(OPpSORT_INPLACE INPLACE), # sort in-place; eg @a = sort @a | |
645 | 4 => qw(OPpSORT_DESCEND DESC ), # Descending sort | |
646 | 5 => qw(OPpSORT_QSORT QSORT ), # Use quicksort (not mergesort) | |
647 | 6 => qw(OPpSORT_STABLE STABLE ), # Use a stable algorithm | |
648 | ); | |
649 | ||
650 | ||
651 | ||
652 | # reverse in-place (@a = reverse @a) */ | |
653 | addbits('reverse', 3 => qw(OPpREVERSE_INPLACE INPLACE)); | |
654 | ||
655 | ||
656 | ||
657 | for (qw(open backtick)) { | |
658 | addbits($_, | |
659 | 4 => qw(OPpOPEN_IN_RAW INBIN ), # binmode(F,":raw") on input fh | |
660 | 5 => qw(OPpOPEN_IN_CRLF INCR ), # binmode(F,":crlf") on input fh | |
661 | 6 => qw(OPpOPEN_OUT_RAW OUTBIN), # binmode(F,":raw") on output fh | |
662 | 7 => qw(OPpOPEN_OUT_CRLF OUTCR ), # binmode(F,":crlf") on output fh | |
663 | ); | |
664 | } | |
665 | ||
666 | ||
667 | ||
668 | # The various OPpFT* filetest ops | |
669 | ||
670 | # "use filetest 'access'" is in scope: | |
671 | # this flag is set only on a subset of the FT* ops | |
672 | addbits($_, 1 => qw(OPpFT_ACCESS FTACCESS)) for ops_with_arg(0, 'F-+'); | |
673 | ||
674 | # all OPpFT* ops except stat and lstat | |
675 | for (grep { $_ !~ /^l?stat$/ } ops_with_flag('-')) { | |
676 | addbits($_, | |
677 | 2 => qw(OPpFT_STACKED FTSTACKED ), # stacked filetest, | |
678 | # e.g. "-f" in "-f -x $foo" | |
679 | 3 => qw(OPpFT_STACKING FTSTACKING), # stacking filetest. | |
680 | # e.g. "-x" in "-f -x $foo" | |
681 | 4 => qw(OPpFT_AFTER_t FTAFTERt ), # previous op was -t | |
682 | ); | |
683 | } | |
684 | ||
685 | ||
686 | ||
687 | addbits($_, 1 => qw(OPpGREP_LEX GREPLEX)) # iterate over lexical $_ | |
688 | for qw(mapwhile mapstart grepwhile grepstart); | |
689 | ||
690 | ||
691 | ||
692 | addbits('entereval', | |
693 | 1 => qw(OPpEVAL_HAS_HH HAS_HH ), # Does it have a copy of %^H ? | |
694 | 2 => qw(OPpEVAL_UNICODE UNI ), | |
695 | 3 => qw(OPpEVAL_BYTES BYTES ), | |
696 | 4 => qw(OPpEVAL_COPHH COPHH ), # Construct %^H from COP hints | |
c486bd5c | 697 | 5 => qw(OPpEVAL_RE_REPARSING REPARSE), # eval_sv(..., G_RE_REPARSING) |
f3574cc6 DM |
698 | ); |
699 | ||
700 | ||
701 | ||
702 | # These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE. | |
703 | # See pp.c:S_rv2gv. */ | |
704 | addbits('coreargs', | |
705 | 0 => qw(OPpCOREARGS_DEREF1 DEREF1), # Arg 1 is a handle constructor | |
706 | 1 => qw(OPpCOREARGS_DEREF2 DEREF2), # Arg 2 is a handle constructor | |
707 | #2 reserved for OPpDONT_INIT_GV in rv2gv | |
708 | #4 reserved for OPpALLOW_FAKE in rv2gv | |
709 | 6 => qw(OPpCOREARGS_SCALARMOD $MOD ), # \$ rather than \[$@%*] | |
710 | 7 => qw(OPpCOREARGS_PUSHMARK MARK ), # Call pp_pushmark | |
711 | ); | |
712 | ||
713 | ||
714 | ||
715 | addbits('split', 7 => qw(OPpSPLIT_IMPLIM IMPLIM)); # implicit limit | |
716 | ||
717 | 1; | |
718 | ||
719 | # ex: set ts=8 sts=4 sw=4 et: |