ext/B/t/optree_varinit.t

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