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 | ||
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 | |
fb0c7c3c FC |
205 | qw(mapstart grepstart), # set in ck_fun, but |
206 | # cleared in ck_grep, | |
207 | # unless there is an error | |
f3574cc6 DM |
208 | grep !$maxarg{$_} && !$args0{$_}, |
209 | ops_with_flag('1'), # UNOP | |
2f7c6295 | 210 | ops_with_flag('+'), # UNOP_AUX |
f3574cc6 DM |
211 | ops_with_flag('%'), # BASEOP/UNOP |
212 | ops_with_flag('|'), # LOGOP | |
213 | ops_with_flag('-'), # FILESTATOP | |
214 | ops_with_flag('}'), # LOOPEXOP | |
b46e009d | 215 | ops_with_flag('.'), # METHOP |
f3574cc6 DM |
216 | ); |
217 | ||
218 | $args2{$_} = 1 for ( | |
219 | qw(vec), | |
220 | grep !$maxarg{$_} && !$args0{$_} && !$args1{$_}, | |
221 | ops_with_flag('2'), # BINOP | |
222 | # this is a binop, but special-cased as a | |
223 | # baseop in regen/opcodes | |
224 | 'sassign', | |
225 | ); | |
226 | ||
227 | $args3{$_} = 1 for grep !$maxarg{$_} && !$args0{$_} | |
228 | && !$args1{$_} && !$args2{$_}, | |
229 | # substr starts off with 4 bits set in | |
230 | # ck_fun(), but since it never has more than 7 | |
231 | # args, bit 3 is later stolen | |
232 | qw(substr); | |
233 | ||
234 | $args4{$_} = 1 for keys %maxarg, | |
235 | grep !$args0{$_} && !$args1{$_} | |
236 | && !$args2{$_} && !$args3{$_}, | |
237 | ops_with_check('ck_fun'), | |
238 | # these other ck_*() functions call ck_fun() | |
239 | ops_with_check('ck_exec'), | |
240 | ops_with_check('ck_glob'), | |
241 | ops_with_check('ck_index'), | |
242 | ops_with_check('ck_join'), | |
243 | ops_with_check('ck_lfun'), | |
244 | ops_with_check('ck_open'), | |
245 | ops_with_check('ck_select'), | |
73f4c4fe | 246 | ops_with_check('ck_stringify'), |
f3574cc6 DM |
247 | ops_with_check('ck_tell'), |
248 | ops_with_check('ck_trunc'), | |
249 | ; | |
250 | ||
251 | ||
252 | for (sort keys %args1) { | |
253 | addbits($_, '0..0' => { | |
254 | mask_def => 'OPpARG1_MASK', | |
255 | label => '-', | |
256 | } | |
257 | ); | |
258 | } | |
259 | ||
260 | for (sort keys %args2) { | |
261 | addbits($_, '0..1' => { | |
262 | mask_def => 'OPpARG2_MASK', | |
263 | label => '-', | |
264 | } | |
265 | ); | |
266 | } | |
267 | ||
268 | for (sort keys %args3) { | |
269 | addbits($_, '0..2' => { | |
270 | mask_def => 'OPpARG3_MASK', | |
271 | label => '-', | |
272 | } | |
273 | ); | |
274 | } | |
275 | ||
276 | for (sort keys %args4) { | |
277 | addbits($_, '0..3' => { | |
278 | mask_def => 'OPpARG4_MASK', | |
279 | label => '-', | |
280 | } | |
281 | ); | |
282 | } | |
283 | } | |
284 | ||
285 | ||
286 | ||
287 | # if NATIVE_HINTS is defined, op_private on cops holds the top 8 bits | |
288 | # of PL_hints, although only bits 6 & 7 are officially used for that | |
289 | # purpose (the rest ought to be masked off). Bit 5 is set separately | |
290 | ||
291 | for (qw(nextstate dbstate)) { | |
292 | addbits($_, | |
293 | 5 => qw(OPpHUSH_VMSISH HUSH), | |
f3574cc6 DM |
294 | ); |
295 | } | |
296 | ||
297 | ||
4e0538d9 DM |
298 | # op is in local context, or pad variable is being introduced, e.g. |
299 | # local $h{foo} | |
300 | # my $x | |
f3574cc6 DM |
301 | |
302 | addbits($_, 7 => qw(OPpLVAL_INTRO LVINTRO)) | |
4e0538d9 | 303 | for qw(gvsv rv2sv rv2hv rv2gv rv2av aelem helem aslice |
f3574cc6 | 304 | hslice delete padsv padav padhv enteriter entersub padrange |
fedf30e1 | 305 | pushmark cond_expr refassign lvref lvrefslice lvavref multideref), |
f3574cc6 DM |
306 | 'list', # this gets set in my_attrs() for some reason |
307 | ; | |
308 | ||
309 | ||
310 | ||
311 | # TARGLEX | |
312 | # | |
313 | # in constructs like my $x; ...; $x = $a + $b, | |
314 | # the sassign is optimised away and OPpTARGET_MY is set on the add op | |
b4941db2 DM |
315 | # |
316 | # Note that OPpTARGET_MY is mainly used at compile-time. At run time, | |
317 | # the pp function just updates the SV pointed to by op_targ, and doesn't | |
318 | # care whether that's a PADTMP or a lexical var. | |
f3574cc6 | 319 | |
16a6edfa DM |
320 | # Some comments about when its safe to use T/OPpTARGET_MY. |
321 | # | |
322 | # Safe to set if the ppcode uses: | |
323 | # tryAMAGICbin, tryAMAGICun, SETn, SETi, SETu, PUSHn, PUSHTARG, SETTARG, | |
324 | # SETs(TARG), XPUSHn, XPUSHu, | |
e83bf98c FC |
325 | # but make sure set-magic is invoked separately for SETs(TARG) (or change |
326 | # it to SETTARG). | |
16a6edfa DM |
327 | # |
328 | # Unsafe to set if the ppcode uses dTARG or [X]RETPUSH[YES|NO|UNDEF] | |
329 | # | |
e83bf98c FC |
330 | # Only the code paths that handle scalar rvalue context matter. If dTARG |
331 | # or RETPUSHNO occurs only in list or lvalue paths, T is safe. | |
332 | # | |
d1455c67 | 333 | # lt and friends do SETs (including ncmp, but not scmp or i_ncmp) |
16a6edfa DM |
334 | # |
335 | # Additional mode of failure: the opcode can modify TARG before it "used" | |
336 | # all the arguments (or may call an external function which does the same). | |
337 | # If the target coincides with one of the arguments ==> kaboom. | |
338 | # | |
339 | # pp.c pos substr each not OK (RETPUSHUNDEF) | |
16a6edfa | 340 | # ref not OK (RETPUSHNO) |
b0da25f0 | 341 | # trans not OK (target is used for lhs, not retval) |
16a6edfa DM |
342 | # ucfirst etc not OK: TMP arg processed inplace |
343 | # quotemeta not OK (unsafe when TARG == arg) | |
d8cdf573 | 344 | # pack - unknown whether it is safe |
16a6edfa DM |
345 | # sprintf: is calling do_sprintf(TARG,...) which can act on TARG |
346 | # before other args are processed. | |
347 | # | |
348 | # Suspicious wrt "additional mode of failure" (and only it): | |
349 | # schop, chop, postinc/dec, bit_and etc, negate, complement. | |
350 | # | |
351 | # Also suspicious: 4-arg substr, sprintf, uc/lc (POK_only), reverse, pack. | |
352 | # | |
353 | # substr/vec: doing TAINT_off()??? | |
354 | # | |
355 | # pp_hot.c | |
356 | # readline - unknown whether it is safe | |
357 | # match subst not OK (dTARG) | |
358 | # grepwhile not OK (not always setting) | |
359 | # join not OK (unsafe when TARG == arg) | |
360 | # | |
8ecc2ae2 FC |
361 | # concat - pp_concat special-cases TARG==arg to avoid |
362 | # "additional mode of failure" | |
16a6edfa DM |
363 | # |
364 | # pp_ctl.c | |
365 | # mapwhile flip caller not OK (not always setting) | |
366 | # | |
367 | # pp_sys.c | |
368 | # backtick glob warn die not OK (not always setting) | |
369 | # warn not OK (RETPUSHYES) | |
370 | # open fileno getc sysread syswrite ioctl accept shutdown | |
371 | # ftsize(etc) readlink telldir fork alarm getlogin not OK (RETPUSHUNDEF) | |
372 | # umask select not OK (XPUSHs(&PL_sv_undef);) | |
373 | # fileno getc sysread syswrite tell not OK (meth("FILENO" "GETC")) | |
374 | # sselect shm* sem* msg* syscall - unknown whether they are safe | |
375 | # gmtime not OK (list context) | |
376 | # | |
377 | # Suspicious wrt "additional mode of failure": warn, die, select. | |
378 | ||
379 | ||
f3574cc6 DM |
380 | addbits($_, 4 => qw(OPpTARGET_MY TARGMY)) |
381 | for ops_with_flag('T'), | |
382 | # This flag is also used to indicate matches against implicit $_, | |
383 | # where $_ is lexical; e.g. my $_; ....; /foo/ | |
57db463f | 384 | qw(match subst pushre qr trans transr); |
f3574cc6 DM |
385 | ; |
386 | ||
387 | ||
388 | ||
389 | ||
390 | ||
391 | # op_targ carries a refcount | |
392 | addbits($_, 6 => qw(OPpREFCOUNTED REFC)) | |
393 | for qw(leave leavesub leavesublv leavewrite leaveeval); | |
394 | ||
395 | ||
396 | ||
397 | # Do not copy return value | |
398 | addbits($_, 7 => qw(OPpLVALUE LV)) for qw(leave leaveloop); | |
399 | ||
400 | ||
401 | ||
402 | # Pattern coming in on the stack | |
403 | addbits($_, 6 => qw(OPpRUNTIME RTIME)) | |
404 | for qw(match subst substcont qr pushre); | |
405 | ||
406 | ||
407 | ||
408 | # autovivify: Want ref to something | |
409 | for (qw(rv2gv rv2sv padsv aelem helem entersub)) { | |
9e209402 | 410 | addbits($_, '4..5' => { |
f3574cc6 DM |
411 | mask_def => 'OPpDEREF', |
412 | enum => [ qw( | |
413 | 1 OPpDEREF_AV DREFAV | |
414 | 2 OPpDEREF_HV DREFHV | |
415 | 3 OPpDEREF_SV DREFSV | |
416 | )], | |
417 | } | |
418 | ); | |
419 | } | |
420 | ||
421 | ||
422 | ||
423 | # Defer creation of array/hash elem | |
fedf30e1 | 424 | addbits($_, 6 => qw(OPpLVAL_DEFER LVDEFER)) for qw(aelem helem multideref); |
f3574cc6 DM |
425 | |
426 | ||
427 | ||
428 | addbits($_, 2 => qw(OPpSLICEWARNING SLICEWARN)) # warn about @hash{$scalar} | |
429 | for qw(rv2hv rv2av padav padhv hslice aslice); | |
430 | ||
431 | ||
432 | ||
433 | # XXX Concise seemed to think that OPpOUR_INTRO is used in rv2gv too, | |
434 | # but I can't see it - DAPM | |
9e209402 | 435 | addbits($_, 6 => qw(OPpOUR_INTRO OURINTR)) # Variable was in an our() |
de183bbb | 436 | for qw(gvsv rv2sv rv2av rv2hv enteriter split); |
f3574cc6 DM |
437 | |
438 | ||
439 | ||
440 | # We might be an lvalue to return | |
441 | addbits($_, 3 => qw(OPpMAYBE_LVSUB LVSUB)) | |
442 | for qw(aassign rv2av rv2gv rv2hv padav padhv aelem helem aslice hslice | |
fedf30e1 | 443 | av2arylen keys rkeys kvaslice kvhslice substr pos vec multideref); |
f3574cc6 DM |
444 | |
445 | ||
446 | ||
447 | for (qw(rv2hv padhv)) { | |
448 | addbits($_, # e.g. %hash in (%hash || $foo) ... | |
9e209402 | 449 | 4 => qw(OPpMAYBE_TRUEBOOL BOOL?), # ... cx not known till run time |
f3574cc6 | 450 | 5 => qw(OPpTRUEBOOL BOOL), # ... in void cxt |
f3574cc6 DM |
451 | ); |
452 | } | |
453 | ||
454 | ||
455 | ||
fedf30e1 DM |
456 | addbits($_, 1 => qw(OPpHINT_STRICT_REFS STRICT)) |
457 | for qw(rv2sv rv2av rv2hv rv2gv multideref); | |
f3574cc6 DM |
458 | |
459 | ||
460 | ||
461 | # Treat caller(1) as caller(2) | |
462 | addbits($_, 7 => qw(OPpOFFBYONE +1)) for qw(caller wantarray runcv); | |
463 | ||
464 | ||
465 | ||
466 | # label is in UTF8 */ | |
467 | addbits($_, 7 => qw(OPpPV_IS_UTF8 UTF)) for qw(last redo next goto dump); | |
468 | ||
469 | ||
470 | ||
471 | # ==================================================================== | |
472 | # | |
473 | # OP-SPECIFIC OPpFOO_* flags: | |
474 | # | |
475 | # where FOO is typically the name of an op, and the flag is used by a | |
476 | # single op (or maybe by a few closely related ops). | |
477 | ||
478 | ||
479 | ||
9e209402 | 480 | addbits($_, 6 => qw(OPpPAD_STATE STATE)) for qw(padav padhv padsv lvavref |
3ad7d304 | 481 | lvref refassign pushmark); |
f3574cc6 DM |
482 | |
483 | ||
484 | ||
485 | addbits('aassign', 6 => qw(OPpASSIGN_COMMON COMMON)); | |
486 | ||
487 | ||
488 | ||
489 | addbits('sassign', | |
490 | 6 => qw(OPpASSIGN_BACKWARDS BKWARD), # Left & right switched | |
491 | 7 => qw(OPpASSIGN_CV_TO_GV CV2GV), # Possible optimisation for constants | |
492 | ); | |
493 | ||
494 | ||
495 | ||
496 | for (qw(trans transr)) { | |
497 | addbits($_, | |
498 | 0 => qw(OPpTRANS_FROM_UTF <UTF), | |
499 | 1 => qw(OPpTRANS_TO_UTF >UTF), | |
500 | 2 => qw(OPpTRANS_IDENTICAL IDENT), # right side is same as left | |
501 | 3 => qw(OPpTRANS_SQUASH SQUASH), | |
502 | # 4 is used for OPpTARGET_MY | |
503 | 5 => qw(OPpTRANS_COMPLEMENT COMPL), | |
504 | 6 => qw(OPpTRANS_GROWS GROWS), | |
505 | 7 => qw(OPpTRANS_DELETE DEL), | |
506 | ); | |
507 | } | |
508 | ||
509 | ||
510 | ||
511 | addbits('repeat', 6 => qw(OPpREPEAT_DOLIST DOLIST)); # List replication | |
512 | ||
513 | ||
514 | ||
515 | # OP_ENTERSUB and OP_RV2CV flags | |
516 | # | |
517 | # Flags are set on entersub and rv2cv in three phases: | |
518 | # parser - the parser passes the flag to the op constructor | |
519 | # check - the check routine called by the op constructor sets the flag | |
520 | # context - application of scalar/ref/lvalue context applies the flag | |
521 | # | |
522 | # In the third stage, an entersub op might turn into an rv2cv op (undef &foo, | |
523 | # \&foo, lock &foo, exists &foo, defined &foo). The two places where that | |
524 | # happens (op_lvalue_flags and doref in op.c) need to make sure the flags do | |
525 | # not conflict, since some flags with different meanings overlap between | |
526 | # the two ops. Flags applied in the context phase are only set when there | |
527 | # is no conversion of op type. | |
528 | # | |
529 | # bit entersub flag phase rv2cv flag phase | |
530 | # --- ------------- ----- ---------- ----- | |
531 | # 0 OPpENTERSUB_INARGS context | |
532 | # 1 HINT_STRICT_REFS check HINT_STRICT_REFS check | |
62ead80f | 533 | # 2 OPpENTERSUB_HASTARG checki OPpENTERSUB_HASTARG |
f3574cc6 | 534 | # 3 OPpENTERSUB_AMPER check OPpENTERSUB_AMPER parser |
9e209402 FC |
535 | # 4 OPpDEREF_AV context |
536 | # 5 OPpDEREF_HV context OPpMAY_RETURN_CONSTANT parser/context | |
537 | # 6 OPpENTERSUB_DB check OPpENTERSUB_DB | |
f3574cc6 DM |
538 | # 7 OPpLVAL_INTRO context OPpENTERSUB_NOPAREN parser |
539 | ||
540 | # NB: OPpHINT_STRICT_REFS must equal HINT_STRICT_REFS | |
541 | ||
542 | addbits('entersub', | |
543 | 0 => qw(OPpENTERSUB_INARGS INARGS), # Lval used as arg to a sub | |
c486bd5c | 544 | 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope |
f3574cc6 DM |
545 | 2 => qw(OPpENTERSUB_HASTARG TARG ), # Called from OP tree |
546 | 3 => qw(OPpENTERSUB_AMPER AMPER), # Used & form to call | |
9e209402 FC |
547 | # 4..5 => OPpDEREF, already defined above |
548 | 6 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine | |
f3574cc6 DM |
549 | # 7 => OPpLVAL_INTRO, already defined above |
550 | ); | |
f3574cc6 | 551 | |
62ead80f DM |
552 | # note that some of these flags are just left-over from when an entersub |
553 | # is converted into an rv2cv, and could probably be cleared/re-assigned | |
f3574cc6 DM |
554 | |
555 | addbits('rv2cv', | |
62ead80f DM |
556 | 1 => qw(OPpHINT_STRICT_REFS STRICT), # 'use strict' in scope |
557 | 2 => qw(OPpENTERSUB_HASTARG TARG ), # If const sub, return the const | |
558 | 3 => qw(OPpENTERSUB_AMPER AMPER ), # Used & form to call | |
62ead80f | 559 | |
9e209402 FC |
560 | 5 => qw(OPpMAY_RETURN_CONSTANT CONST ), |
561 | 6 => qw(OPpENTERSUB_DB DBG ), # Debug subroutine | |
62ead80f | 562 | 7 => qw(OPpENTERSUB_NOPAREN NO() ), # bare sub call (without parens) |
f3574cc6 DM |
563 | ); |
564 | ||
565 | ||
566 | ||
567 | #foo() called before sub foo was parsed */ | |
568 | addbits('gv', 5 => qw(OPpEARLY_CV EARLYCV)); | |
569 | ||
570 | ||
571 | ||
572 | # 1st arg is replacement string */ | |
573 | addbits('substr', 4 => qw(OPpSUBSTR_REPL_FIRST REPL1ST)); | |
574 | ||
575 | ||
576 | ||
577 | addbits('padrange', | |
578 | # bits 0..6 hold target range | |
579 | '0..6' => { | |
580 | label => '-', | |
581 | mask_def => 'OPpPADRANGE_COUNTMASK', | |
582 | bitcount_def => 'OPpPADRANGE_COUNTSHIFT', | |
583 | } | |
584 | # 7 => OPpLVAL_INTRO, already defined above | |
585 | ); | |
586 | ||
587 | ||
588 | ||
589 | for (qw(aelemfast aelemfast_lex)) { | |
590 | addbits($_, | |
591 | '0..7' => { | |
592 | label => '-', | |
593 | } | |
594 | ); | |
595 | } | |
596 | ||
597 | ||
598 | ||
599 | addbits('rv2gv', | |
600 | 2 => qw(OPpDONT_INIT_GV NOINIT), # Call gv_fetchpv with GV_NOINIT | |
601 | # (Therefore will return whatever is currently in | |
602 | # the symbol table, not guaranteed to be a PVGV) | |
9e209402 | 603 | 6 => qw(OPpALLOW_FAKE FAKE), # OK to return fake glob |
f3574cc6 DM |
604 | ); |
605 | ||
606 | ||
607 | ||
608 | addbits('enteriter', | |
609 | 2 => qw(OPpITER_REVERSED REVERSED),# for (reverse ...) | |
c486bd5c | 610 | 3 => qw(OPpITER_DEF DEF), # 'for $_' or 'for my $_' |
f3574cc6 DM |
611 | ); |
612 | addbits('iter', 2 => qw(OPpITER_REVERSED REVERSED)); | |
613 | ||
614 | ||
615 | ||
616 | addbits('const', | |
617 | 1 => qw(OPpCONST_NOVER NOVER), # no 6; | |
618 | 2 => qw(OPpCONST_SHORTCIRCUIT SHORT), # e.g. the constant 5 in (5 || foo) | |
619 | 3 => qw(OPpCONST_STRICT STRICT), # bareword subject to strict 'subs' | |
620 | 4 => qw(OPpCONST_ENTERED ENTERED), # Has been entered as symbol | |
621 | 6 => qw(OPpCONST_BARE BARE), # Was a bare word (filehandle?) | |
622 | ); | |
623 | ||
624 | ||
625 | ||
626 | # Range arg potentially a line num. */ | |
627 | addbits($_, 6 => qw(OPpFLIP_LINENUM LINENUM)) for qw(flip flop); | |
628 | ||
629 | ||
630 | ||
631 | # Guessed that pushmark was needed. */ | |
632 | addbits('list', 6 => qw(OPpLIST_GUESSED GUESSED)); | |
633 | ||
634 | ||
635 | ||
636 | # Operating on a list of keys | |
637 | addbits('delete', 6 => qw(OPpSLICE SLICE)); | |
638 | # also 7 => OPpLVAL_INTRO, already defined above | |
639 | ||
640 | ||
641 | ||
642 | # Checking for &sub, not {} or []. | |
643 | addbits('exists', 6 => qw(OPpEXISTS_SUB SUB)); | |
644 | ||
645 | ||
646 | ||
647 | addbits('sort', | |
648 | 0 => qw(OPpSORT_NUMERIC NUM ), # Optimized away { $a <=> $b } | |
649 | 1 => qw(OPpSORT_INTEGER INT ), # Ditto while under "use integer" | |
650 | 2 => qw(OPpSORT_REVERSE REV ), # Reversed sort | |
651 | 3 => qw(OPpSORT_INPLACE INPLACE), # sort in-place; eg @a = sort @a | |
652 | 4 => qw(OPpSORT_DESCEND DESC ), # Descending sort | |
653 | 5 => qw(OPpSORT_QSORT QSORT ), # Use quicksort (not mergesort) | |
654 | 6 => qw(OPpSORT_STABLE STABLE ), # Use a stable algorithm | |
655 | ); | |
656 | ||
657 | ||
658 | ||
659 | # reverse in-place (@a = reverse @a) */ | |
660 | addbits('reverse', 3 => qw(OPpREVERSE_INPLACE INPLACE)); | |
661 | ||
662 | ||
663 | ||
664 | for (qw(open backtick)) { | |
665 | addbits($_, | |
666 | 4 => qw(OPpOPEN_IN_RAW INBIN ), # binmode(F,":raw") on input fh | |
667 | 5 => qw(OPpOPEN_IN_CRLF INCR ), # binmode(F,":crlf") on input fh | |
668 | 6 => qw(OPpOPEN_OUT_RAW OUTBIN), # binmode(F,":raw") on output fh | |
669 | 7 => qw(OPpOPEN_OUT_CRLF OUTCR ), # binmode(F,":crlf") on output fh | |
670 | ); | |
671 | } | |
672 | ||
673 | ||
674 | ||
675 | # The various OPpFT* filetest ops | |
676 | ||
677 | # "use filetest 'access'" is in scope: | |
678 | # this flag is set only on a subset of the FT* ops | |
679 | addbits($_, 1 => qw(OPpFT_ACCESS FTACCESS)) for ops_with_arg(0, 'F-+'); | |
680 | ||
681 | # all OPpFT* ops except stat and lstat | |
682 | for (grep { $_ !~ /^l?stat$/ } ops_with_flag('-')) { | |
683 | addbits($_, | |
684 | 2 => qw(OPpFT_STACKED FTSTACKED ), # stacked filetest, | |
685 | # e.g. "-f" in "-f -x $foo" | |
686 | 3 => qw(OPpFT_STACKING FTSTACKING), # stacking filetest. | |
687 | # e.g. "-x" in "-f -x $foo" | |
688 | 4 => qw(OPpFT_AFTER_t FTAFTERt ), # previous op was -t | |
689 | ); | |
690 | } | |
691 | ||
692 | ||
693 | ||
694 | addbits($_, 1 => qw(OPpGREP_LEX GREPLEX)) # iterate over lexical $_ | |
695 | for qw(mapwhile mapstart grepwhile grepstart); | |
696 | ||
697 | ||
698 | ||
699 | addbits('entereval', | |
700 | 1 => qw(OPpEVAL_HAS_HH HAS_HH ), # Does it have a copy of %^H ? | |
701 | 2 => qw(OPpEVAL_UNICODE UNI ), | |
702 | 3 => qw(OPpEVAL_BYTES BYTES ), | |
703 | 4 => qw(OPpEVAL_COPHH COPHH ), # Construct %^H from COP hints | |
c486bd5c | 704 | 5 => qw(OPpEVAL_RE_REPARSING REPARSE), # eval_sv(..., G_RE_REPARSING) |
f3574cc6 DM |
705 | ); |
706 | ||
707 | ||
708 | ||
709 | # These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE. | |
710 | # See pp.c:S_rv2gv. */ | |
711 | addbits('coreargs', | |
712 | 0 => qw(OPpCOREARGS_DEREF1 DEREF1), # Arg 1 is a handle constructor | |
713 | 1 => qw(OPpCOREARGS_DEREF2 DEREF2), # Arg 2 is a handle constructor | |
714 | #2 reserved for OPpDONT_INIT_GV in rv2gv | |
715 | #4 reserved for OPpALLOW_FAKE in rv2gv | |
716 | 6 => qw(OPpCOREARGS_SCALARMOD $MOD ), # \$ rather than \[$@%*] | |
717 | 7 => qw(OPpCOREARGS_PUSHMARK MARK ), # Call pp_pushmark | |
718 | ); | |
719 | ||
720 | ||
721 | ||
722 | addbits('split', 7 => qw(OPpSPLIT_IMPLIM IMPLIM)); # implicit limit | |
723 | ||
6102323a FC |
724 | |
725 | ||
726 | addbits($_, | |
727 | 2 => qw(OPpLVREF_ELEM ELEM ), | |
5a36b2c0 | 728 | 3 => qw(OPpLVREF_ITER ITER ), |
9e209402 | 729 | '4..5'=> { |
c2380ea1 FC |
730 | mask_def => 'OPpLVREF_TYPE', |
731 | enum => [ qw( | |
732 | 0 OPpLVREF_SV SV | |
733 | 1 OPpLVREF_AV AV | |
734 | 2 OPpLVREF_HV HV | |
735 | 3 OPpLVREF_CV CV | |
736 | )], | |
737 | }, | |
6102323a FC |
738 | #7 => qw(OPpLVAL_INTRO LVINTRO), |
739 | ) for 'refassign', 'lvref'; | |
740 | ||
fedf30e1 DM |
741 | |
742 | ||
743 | addbits('multideref', | |
744 | 4 => qw(OPpMULTIDEREF_EXISTS EXISTS), # deref is actually exists | |
745 | 5 => qw(OPpMULTIDEREF_DELETE DELETE), # deref is actually delete | |
746 | ); | |
747 | ||
f3574cc6 DM |
748 | 1; |
749 | ||
750 | # ex: set ts=8 sts=4 sw=4 et: |