ext/B/t/optree_varinit.t

   1 #!perl
   2
   3 BEGIN {
   4     chdir 't';
   5     @INC = ('../lib', '../ext/B/t');
   6     require Config;
   7     if (($Config::Config{'extensions'} !~ /\bB\b/) ){
   8         print "1..0 # Skip -- Perl configured without B module\n";
   9         exit 0;
  10     }
  11     if ($Config::Config{'extensions'} !~ /\bData\/Dumper\b/) {
  12         print
  13             "1..0 # Skip: Data::Dumper was not built, needed by OptreeCheck\n";
  14         exit 0;
  15     }
  16     require './test.pl';
  17 }
  18 use OptreeCheck;
  19 use Config;
  20 plan tests      => 22;
  21 SKIP: {
  22 skip "no perlio in this build", 22 unless $Config::Config{useperlio};
  23
  24 pass("OPTIMIZER TESTS - VAR INITIALIZATION");
  25
  26 checkOptree ( name      => 'sub {my $a}',
  27               bcopts    => '-exec',
  28               code      => sub {my $a},
  29               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  30 # 1  <;> nextstate(main 45 optree.t:23) v
  31 # 2  <0> padsv[$a:45,46] M/LVINTRO
  32 # 3  <1> leavesub[1 ref] K/REFC,1
  33 EOT_EOT
  34 # 1  <;> nextstate(main 45 optree.t:23) v
  35 # 2  <0> padsv[$a:45,46] M/LVINTRO
  36 # 3  <1> leavesub[1 ref] K/REFC,1
  37 EONT_EONT
  38
  39 checkOptree ( name      => '-exec sub {my $a}',
  40               bcopts    => '-exec',
  41               code      => sub {my $a},
  42               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  43 # 1  <;> nextstate(main 49 optree.t:52) v
  44 # 2  <0> padsv[$a:49,50] M/LVINTRO
  45 # 3  <1> leavesub[1 ref] K/REFC,1
  46 EOT_EOT
  47 # 1  <;> nextstate(main 49 optree.t:45) v
  48 # 2  <0> padsv[$a:49,50] M/LVINTRO
  49 # 3  <1> leavesub[1 ref] K/REFC,1
  50 EONT_EONT
  51
  52 checkOptree ( name      => 'sub {our $a}',
  53               bcopts    => '-exec',
  54               code      => sub {our $a},
  55               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  56 1  <;> nextstate(main 21 optree.t:47) v
  57 2  <#> gvsv[*a] s/OURINTR
  58 3  <1> leavesub[1 ref] K/REFC,1
  59 EOT_EOT
  60 # 1  <;> nextstate(main 51 optree.t:56) v
  61 # 2  <$> gvsv(*a) s/OURINTR
  62 # 3  <1> leavesub[1 ref] K/REFC,1
  63 EONT_EONT
  64
  65 checkOptree ( name      => 'sub {local $a}',
  66               bcopts    => '-exec',
  67               code      => sub {local $a},
  68               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  69 1  <;> nextstate(main 23 optree.t:57) v
  70 2  <#> gvsv[*a] s/LVINTRO
  71 3  <1> leavesub[1 ref] K/REFC,1
  72 EOT_EOT
  73 # 1  <;> nextstate(main 53 optree.t:67) v
  74 # 2  <$> gvsv(*a) s/LVINTRO
  75 # 3  <1> leavesub[1 ref] K/REFC,1
  76 EONT_EONT
  77
  78 checkOptree ( name      => 'my $a',
  79               prog      => 'my $a',
  80               bcopts    => '-basic',
  81               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  82 # 4  <@> leave[1 ref] vKP/REFC ->(end)
  83 # 1     <0> enter ->2
  84 # 2     <;> nextstate(main 1 -e:1) v ->3
  85 # 3     <0> padsv[$a:1,2] vM/LVINTRO ->4
  86 EOT_EOT
  87 # 4  <@> leave[1 ref] vKP/REFC ->(end)
  88 # 1     <0> enter ->2
  89 # 2     <;> nextstate(main 1 -e:1) v ->3
  90 # 3     <0> padsv[$a:1,2] vM/LVINTRO ->4
  91 EONT_EONT
  92
  93 checkOptree ( name      => 'our $a',
  94               prog      => 'our $a',
  95               bcopts    => '-basic',
  96               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  97 4  <@> leave[1 ref] vKP/REFC ->(end)
  98 1     <0> enter ->2
  99 2     <;> nextstate(main 1 -e:1) v ->3
 100 -     <1> ex-rv2sv vK/17 ->4
 101 3        <#> gvsv[*a] s/OURINTR ->4
 102 EOT_EOT
 103 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 104 # 1     <0> enter ->2
 105 # 2     <;> nextstate(main 1 -e:1) v ->3
 106 # -     <1> ex-rv2sv vK/17 ->4
 107 # 3        <$> gvsv(*a) s/OURINTR ->4
 108 EONT_EONT
 109
 110 checkOptree ( name      => 'local $a',
 111               prog      => 'local $a',
 112               bcopts    => '-basic',
 113               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 114 4  <@> leave[1 ref] vKP/REFC ->(end)
 115 1     <0> enter ->2
 116 2     <;> nextstate(main 1 -e:1) v ->3
 117 -     <1> ex-rv2sv vKM/129 ->4
 118 3        <#> gvsv[*a] s/LVINTRO ->4
 119 EOT_EOT
 120 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 121 # 1     <0> enter ->2
 122 # 2     <;> nextstate(main 1 -e:1) v ->3
 123 # -     <1> ex-rv2sv vKM/129 ->4
 124 # 3        <$> gvsv(*a) s/LVINTRO ->4
 125 EONT_EONT
 126
 127 pass("MY, OUR, LOCAL, BOTH SUB AND MAIN, = undef");
 128
 129 checkOptree ( name      => 'sub {my $a=undef}',
 130               code      => sub {my $a=undef},
 131               bcopts    => '-basic',
 132               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 133 3  <1> leavesub[1 ref] K/REFC,1 ->(end)
 134 -     <@> lineseq KP ->3
 135 1        <;> nextstate(main 24 optree.t:99) v ->2
 136 2        <0> padsv[$a:24,25] sRM*/LVINTRO ->3
 137 EOT_EOT
 138 # 3  <1> leavesub[1 ref] K/REFC,1 ->(end)
 139 # -     <@> lineseq KP ->3
 140 # 1        <;> nextstate(main 54 optree.t:149) v ->2
 141 # 2        <0> padsv[$a:54,55] sRM*/LVINTRO ->3
 142 EONT_EONT
 143
 144 checkOptree ( name      => 'sub {our $a=undef}',
 145               code      => sub {our $a=undef},
 146               note      => 'the global must be reset',
 147               bcopts    => '-basic',
 148               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 149 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 150 -     <@> lineseq KP ->5
 151 1        <;> nextstate(main 26 optree.t:109) v ->2
 152 4        <2> sassign sKS/2 ->5
 153 2           <0> undef s ->3
 154 -           <1> ex-rv2sv sKRM*/17 ->4
 155 3              <#> gvsv[*a] s/OURINTR ->4
 156 EOT_EOT
 157 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 158 # -     <@> lineseq KP ->5
 159 # 1        <;> nextstate(main 446 optree_varinit.t:137) v ->2
 160 # 4        <2> sassign sKS/2 ->5
 161 # 2           <0> undef s ->3
 162 # -           <1> ex-rv2sv sKRM*/17 ->4
 163 # 3              <$> gvsv(*a) s/OURINTR ->4
 164 EONT_EONT
 165
 166 checkOptree ( name      => 'sub {local $a=undef}',
 167               code      => sub {local $a=undef},
 168               note      => 'local not used enough to bother',
 169               bcopts    => '-basic',
 170               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 171 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 172 -     <@> lineseq KP ->5
 173 1        <;> nextstate(main 28 optree.t:122) v ->2
 174 4        <2> sassign sKS/2 ->5
 175 2           <0> undef s ->3
 176 -           <1> ex-rv2sv sKRM*/129 ->4
 177 3              <#> gvsv[*a] s/LVINTRO ->4
 178 EOT_EOT
 179 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 180 # -     <@> lineseq KP ->5
 181 # 1        <;> nextstate(main 58 optree.t:141) v ->2
 182 # 4        <2> sassign sKS/2 ->5
 183 # 2           <0> undef s ->3
 184 # -           <1> ex-rv2sv sKRM*/129 ->4
 185 # 3              <$> gvsv(*a) s/LVINTRO ->4
 186 EONT_EONT
 187
 188 checkOptree ( name      => 'my $a=undef',
 189               prog      => 'my $a=undef',
 190               bcopts    => '-basic',
 191               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 192 4  <@> leave[1 ref] vKP/REFC ->(end)
 193 1     <0> enter ->2
 194 2     <;> nextstate(main 1 -e:1) v ->3
 195 3     <0> padsv[$a:1,2] vRM*/LVINTRO ->4
 196 EOT_EOT
 197 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 198 # 1     <0> enter ->2
 199 # 2     <;> nextstate(main 1 -e:1) v ->3
 200 # 3     <0> padsv[$a:1,2] vRM*/LVINTRO ->4
 201 EONT_EONT
 202
 203 checkOptree ( name      => 'our $a=undef',
 204               prog      => 'our $a=undef',
 205               note      => 'global must be reassigned',
 206               bcopts    => '-basic',
 207               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 208 6  <@> leave[1 ref] vKP/REFC ->(end)
 209 1     <0> enter ->2
 210 2     <;> nextstate(main 1 -e:1) v ->3
 211 5     <2> sassign vKS/2 ->6
 212 3        <0> undef s ->4
 213 -        <1> ex-rv2sv sKRM*/17 ->5
 214 4           <#> gvsv[*a] s/OURINTR ->5
 215 EOT_EOT
 216 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 217 # 1     <0> enter ->2
 218 # 2     <;> nextstate(main 1 -e:1) v ->3
 219 # 5     <2> sassign vKS/2 ->6
 220 # 3        <0> undef s ->4
 221 # -        <1> ex-rv2sv sKRM*/17 ->5
 222 # 4           <$> gvsv(*a) s/OURINTR ->5
 223 EONT_EONT
 224
 225 checkOptree ( name      => 'local $a=undef',
 226               prog      => 'local $a=undef',
 227               note      => 'locals are rare, probly not worth doing',
 228               bcopts    => '-basic',
 229               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 230 6  <@> leave[1 ref] vKP/REFC ->(end)
 231 1     <0> enter ->2
 232 2     <;> nextstate(main 1 -e:1) v ->3
 233 5     <2> sassign vKS/2 ->6
 234 3        <0> undef s ->4
 235 -        <1> ex-rv2sv sKRM*/129 ->5
 236 4           <#> gvsv[*a] s/LVINTRO ->5
 237 EOT_EOT
 238 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 239 # 1     <0> enter ->2
 240 # 2     <;> nextstate(main 1 -e:1) v ->3
 241 # 5     <2> sassign vKS/2 ->6
 242 # 3        <0> undef s ->4
 243 # -        <1> ex-rv2sv sKRM*/129 ->5
 244 # 4           <$> gvsv(*a) s/LVINTRO ->5
 245 EONT_EONT
 246
 247 checkOptree ( name      => 'sub {my $a=()}',
 248               code      => sub {my $a=()},
 249               todo      => 'apparently done, by patch #?',
 250               bcopts    => '-exec',
 251               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 252 1  <;> nextstate(main -439 optree.t:105) v
 253 2  <0> stub sP
 254 3  <0> padsv[$a:-439,-438] sRM*/LVINTRO
 255 4  <2> sassign sKS/2
 256 5  <1> leavesub[1 ref] K/REFC,1
 257 EOT_EOT
 258 # 1  <;> nextstate(main 438 optree_varinit.t:247) v
 259 # 2  <0> stub sP
 260 # 3  <0> padsv[$a:438,439] sRM*/LVINTRO
 261 # 4  <2> sassign sKS/2
 262 # 5  <1> leavesub[1 ref] K/REFC,1
 263 EONT_EONT
 264
 265 checkOptree ( name      => 'sub {our $a=()}',
 266               code      => sub {our $a=()},
 267               #todo     => 'probly not worth doing',
 268               bcopts    => '-exec',
 269               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 270 1  <;> nextstate(main 31 optree.t:177) v
 271 2  <0> stub sP
 272 3  <#> gvsv[*a] s/OURINTR
 273 4  <2> sassign sKS/2
 274 5  <1> leavesub[1 ref] K/REFC,1
 275 EOT_EOT
 276 # 1  <;> nextstate(main 440 optree_varinit.t:262) v
 277 # 2  <0> stub sP
 278 # 3  <$> gvsv(*a) s/OURINTR
 279 # 4  <2> sassign sKS/2
 280 # 5  <1> leavesub[1 ref] K/REFC,1
 281 EONT_EONT
 282
 283 checkOptree ( name      => 'sub {local $a=()}',
 284               code      => sub {local $a=()},
 285               #todo     => 'probly not worth doing',
 286               bcopts    => '-exec',
 287               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 288 1  <;> nextstate(main 33 optree.t:190) v
 289 2  <0> stub sP
 290 3  <#> gvsv[*a] s/LVINTRO
 291 4  <2> sassign sKS/2
 292 5  <1> leavesub[1 ref] K/REFC,1
 293 EOT_EOT
 294 # 1  <;> nextstate(main 63 optree.t:225) v
 295 # 2  <0> stub sP
 296 # 3  <$> gvsv(*a) s/LVINTRO
 297 # 4  <2> sassign sKS/2
 298 # 5  <1> leavesub[1 ref] K/REFC,1
 299 EONT_EONT
 300
 301 checkOptree ( name      => 'my $a=()',
 302               prog      => 'my $a=()',
 303               todo      => 'apparently done, by patch #?',
 304               bcopts    => '-exec',
 305               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 306 1  <0> enter
 307 2  <;> nextstate(main 1 -e:1) v
 308 3  <0> stub sP
 309 4  <0> padsv[$a:1,2] sRM*/LVINTRO
 310 5  <2> sassign vKS/2
 311 6  <@> leave[1 ref] vKP/REFC
 312 EOT_EOT
 313 # 1  <0> enter
 314 # 2  <;> nextstate(main 1 -e:1) v
 315 # 3  <0> stub sP
 316 # 4  <0> padsv[$a:1,2] sRM*/LVINTRO
 317 # 5  <2> sassign vKS/2
 318 # 6  <@> leave[1 ref] vKP/REFC
 319 EONT_EONT
 320
 321 checkOptree ( name      => 'our $a=()',
 322               prog      => 'our $a=()',
 323               #todo     => 'probly not worth doing',
 324               bcopts    => '-exec',
 325               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 326 1  <0> enter
 327 2  <;> nextstate(main 1 -e:1) v
 328 3  <0> stub sP
 329 4  <#> gvsv[*a] s/OURINTR
 330 5  <2> sassign vKS/2
 331 6  <@> leave[1 ref] vKP/REFC
 332 EOT_EOT
 333 # 1  <0> enter
 334 # 2  <;> nextstate(main 1 -e:1) v
 335 # 3  <0> stub sP
 336 # 4  <$> gvsv(*a) s/OURINTR
 337 # 5  <2> sassign vKS/2
 338 # 6  <@> leave[1 ref] vKP/REFC
 339 EONT_EONT
 340
 341 checkOptree ( name      => 'local $a=()',
 342               prog      => 'local $a=()',
 343               #todo     => 'probly not worth doing',
 344               bcopts    => '-exec',
 345               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 346 1  <0> enter
 347 2  <;> nextstate(main 1 -e:1) v
 348 3  <0> stub sP
 349 4  <#> gvsv[*a] s/LVINTRO
 350 5  <2> sassign vKS/2
 351 6  <@> leave[1 ref] vKP/REFC
 352 EOT_EOT
 353 # 1  <0> enter
 354 # 2  <;> nextstate(main 1 -e:1) v
 355 # 3  <0> stub sP
 356 # 4  <$> gvsv(*a) s/LVINTRO
 357 # 5  <2> sassign vKS/2
 358 # 6  <@> leave[1 ref] vKP/REFC
 359 EONT_EONT
 360
 361 checkOptree ( name      => 'my ($a,$b)=()',
 362               prog      => 'my ($a,$b)=()',
 363               #todo     => 'probly not worth doing',
 364               bcopts    => '-exec',
 365               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 366 # 1  <0> enter
 367 # 2  <;> nextstate(main 1 -e:1) v
 368 # 3  <0> pushmark s
 369 # 4  <0> pushmark sRM*/128
 370 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 371 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 372 # 7  <2> aassign[t3] vKS
 373 # 8  <@> leave[1 ref] vKP/REFC
 374 EOT_EOT
 375 # 1  <0> enter
 376 # 2  <;> nextstate(main 1 -e:1) v
 377 # 3  <0> pushmark s
 378 # 4  <0> pushmark sRM*/128
 379 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 380 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 381 # 7  <2> aassign[t3] vKS
 382 # 8  <@> leave[1 ref] vKP/REFC
 383 EONT_EONT
 384
 385 } #skip
 386
 387 __END__
 388