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     # require 'test.pl'; # now done by OptreeCheck
  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               @open_todo,
  30               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  31 # 1  <;> nextstate(main 45 optree.t:23) v
  32 # 2  <0> padsv[$a:45,46] M/LVINTRO
  33 # 3  <1> leavesub[1 ref] K/REFC,1
  34 EOT_EOT
  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 EONT_EONT
  39
  40 checkOptree ( name      => '-exec sub {my $a}',
  41               bcopts    => '-exec',
  42               code      => sub {my $a},
  43               @open_todo,
  44               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  45 # 1  <;> nextstate(main 49 optree.t:52) v
  46 # 2  <0> padsv[$a:49,50] M/LVINTRO
  47 # 3  <1> leavesub[1 ref] K/REFC,1
  48 EOT_EOT
  49 # 1  <;> nextstate(main 49 optree.t:45) v
  50 # 2  <0> padsv[$a:49,50] M/LVINTRO
  51 # 3  <1> leavesub[1 ref] K/REFC,1
  52 EONT_EONT
  53
  54 checkOptree ( name      => 'sub {our $a}',
  55               bcopts    => '-exec',
  56               code      => sub {our $a},
  57               @open_todo,
  58               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  59 1  <;> nextstate(main 21 optree.t:47) v
  60 2  <#> gvsv[*a] s/OURINTR
  61 3  <1> leavesub[1 ref] K/REFC,1
  62 EOT_EOT
  63 # 1  <;> nextstate(main 51 optree.t:56) v
  64 # 2  <$> gvsv(*a) s/OURINTR
  65 # 3  <1> leavesub[1 ref] K/REFC,1
  66 EONT_EONT
  67
  68 checkOptree ( name      => 'sub {local $a}',
  69               bcopts    => '-exec',
  70               code      => sub {local $a},
  71               @open_todo,
  72               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
  73 1  <;> nextstate(main 23 optree.t:57) v:{
  74 2  <#> gvsv[*a] s/LVINTRO
  75 3  <1> leavesub[1 ref] K/REFC,1
  76 EOT_EOT
  77 # 1  <;> nextstate(main 53 optree.t:67) v:{
  78 # 2  <$> gvsv(*a) s/LVINTRO
  79 # 3  <1> leavesub[1 ref] K/REFC,1
  80 EONT_EONT
  81
  82 checkOptree ( name      => 'my $a',
  83               prog      => 'my $a',
  84               bcopts    => '-basic',
  85               @open_todo,
  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               @open_todo,
 102               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 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 EOT_EOT
 109 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 110 # 1     <0> enter ->2
 111 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 112 # -     <1> ex-rv2sv vK/17 ->4
 113 # 3        <$> gvsv(*a) s/OURINTR ->4
 114 EONT_EONT
 115
 116 checkOptree ( name      => 'local $a',
 117               prog      => 'local $a',
 118               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 119               bcopts    => '-basic',
 120               @open_todo,
 121               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 122 4  <@> leave[1 ref] vKP/REFC ->(end)
 123 1     <0> enter ->2
 124 2     <;> nextstate(main 1 -e:1) v:{ ->3
 125 -     <1> ex-rv2sv vKM/129 ->4
 126 3        <#> gvsv[*a] s/LVINTRO ->4
 127 EOT_EOT
 128 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 129 # 1     <0> enter ->2
 130 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 131 # -     <1> ex-rv2sv vKM/129 ->4
 132 # 3        <$> gvsv(*a) s/LVINTRO ->4
 133 EONT_EONT
 134
 135 pass("MY, OUR, LOCAL, BOTH SUB AND MAIN, = undef");
 136
 137 checkOptree ( name      => 'sub {my $a=undef}',
 138               code      => sub {my $a=undef},
 139               bcopts    => '-basic',
 140               @open_todo,
 141               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 142 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 143 -     <@> lineseq KP ->5
 144 1        <;> nextstate(main 641 optree_varinit.t:130) v ->2
 145 4        <2> sassign sKS/2 ->5
 146 2           <0> undef s ->3
 147 3           <0> padsv[$a:641,642] sRM*/LVINTRO ->4
 148 EOT_EOT
 149 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 150 # -     <@> lineseq KP ->5
 151 # 1        <;> nextstate(main 641 optree_varinit.t:130) v ->2
 152 # 4        <2> sassign sKS/2 ->5
 153 # 2           <0> undef s ->3
 154 # 3           <0> padsv[$a:641,642] sRM*/LVINTRO ->4
 155 EONT_EONT
 156
 157 checkOptree ( name      => 'sub {our $a=undef}',
 158               code      => sub {our $a=undef},
 159               note      => 'the global must be reset',
 160               bcopts    => '-basic',
 161               @open_todo,
 162               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 163 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 164 -     <@> lineseq KP ->5
 165 1        <;> nextstate(main 26 optree.t:109) v:{ ->2
 166 4        <2> sassign sKS/2 ->5
 167 2           <0> undef s ->3
 168 -           <1> ex-rv2sv sKRM*/17 ->4
 169 3              <#> gvsv[*a] s/OURINTR ->4
 170 EOT_EOT
 171 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 172 # -     <@> lineseq KP ->5
 173 # 1        <;> nextstate(main 446 optree_varinit.t:137) v:{ ->2
 174 # 4        <2> sassign sKS/2 ->5
 175 # 2           <0> undef s ->3
 176 # -           <1> ex-rv2sv sKRM*/17 ->4
 177 # 3              <$> gvsv(*a) s/OURINTR ->4
 178 EONT_EONT
 179
 180 checkOptree ( name      => 'sub {local $a=undef}',
 181               code      => sub {local $a=undef},
 182               note      => 'local not used enough to bother',
 183               bcopts    => '-basic',
 184               @open_todo,
 185               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 186 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 187 -     <@> lineseq KP ->5
 188 1        <;> nextstate(main 28 optree.t:122) v:{ ->2
 189 4        <2> sassign sKS/2 ->5
 190 2           <0> undef s ->3
 191 -           <1> ex-rv2sv sKRM*/129 ->4
 192 3              <#> gvsv[*a] s/LVINTRO ->4
 193 EOT_EOT
 194 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 195 # -     <@> lineseq KP ->5
 196 # 1        <;> nextstate(main 58 optree.t:141) v:{ ->2
 197 # 4        <2> sassign sKS/2 ->5
 198 # 2           <0> undef s ->3
 199 # -           <1> ex-rv2sv sKRM*/129 ->4
 200 # 3              <$> gvsv(*a) s/LVINTRO ->4
 201 EONT_EONT
 202
 203 checkOptree ( name      => 'my $a=undef',
 204               prog      => 'my $a=undef',
 205               bcopts    => '-basic',
 206               @open_todo,
 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 4        <0> padsv[$a:1,2] sRM*/LVINTRO ->5
 214 EOT_EOT
 215 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 216 # 1     <0> enter ->2
 217 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 218 # 5     <2> sassign vKS/2 ->6
 219 # 3        <0> undef s ->4
 220 # 4        <0> padsv[$a:1,2] sRM*/LVINTRO ->5
 221 EONT_EONT
 222
 223 checkOptree ( name      => 'our $a=undef',
 224               prog      => 'our $a=undef',
 225               note      => 'global must be reassigned',
 226               bcopts    => '-basic',
 227               @open_todo,
 228               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 229 6  <@> leave[1 ref] vKP/REFC ->(end)
 230 1     <0> enter ->2
 231 2     <;> nextstate(main 1 -e:1) v:{ ->3
 232 5     <2> sassign vKS/2 ->6
 233 3        <0> undef s ->4
 234 -        <1> ex-rv2sv sKRM*/17 ->5
 235 4           <#> gvsv[*a] s/OURINTR ->5
 236 EOT_EOT
 237 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 238 # 1     <0> enter ->2
 239 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 240 # 5     <2> sassign vKS/2 ->6
 241 # 3        <0> undef s ->4
 242 # -        <1> ex-rv2sv sKRM*/17 ->5
 243 # 4           <$> gvsv(*a) s/OURINTR ->5
 244 EONT_EONT
 245
 246 checkOptree ( name      => 'local $a=undef',
 247               prog      => 'local $a=undef',
 248               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 249               note      => 'locals are rare, probly not worth doing',
 250               bcopts    => '-basic',
 251               @open_todo,
 252               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 253 6  <@> leave[1 ref] vKP/REFC ->(end)
 254 1     <0> enter ->2
 255 2     <;> nextstate(main 1 -e:1) v:{ ->3
 256 5     <2> sassign vKS/2 ->6
 257 3        <0> undef s ->4
 258 -        <1> ex-rv2sv sKRM*/129 ->5
 259 4           <#> gvsv[*a] s/LVINTRO ->5
 260 EOT_EOT
 261 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 262 # 1     <0> enter ->2
 263 # 2     <;> nextstate(main 1 -e:1) v:{ ->3
 264 # 5     <2> sassign vKS/2 ->6
 265 # 3        <0> undef s ->4
 266 # -        <1> ex-rv2sv sKRM*/129 ->5
 267 # 4           <$> gvsv(*a) s/LVINTRO ->5
 268 EONT_EONT
 269
 270 checkOptree ( name      => 'sub {my $a=()}',
 271               code      => sub {my $a=()},
 272               bcopts    => '-exec',
 273               @open_todo,
 274               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 275 1  <;> nextstate(main -439 optree.t:105) v
 276 2  <0> stub sP
 277 3  <0> padsv[$a:-439,-438] sRM*/LVINTRO
 278 4  <2> sassign sKS/2
 279 5  <1> leavesub[1 ref] K/REFC,1
 280 EOT_EOT
 281 # 1  <;> nextstate(main 438 optree_varinit.t:247) v
 282 # 2  <0> stub sP
 283 # 3  <0> padsv[$a:438,439] sRM*/LVINTRO
 284 # 4  <2> sassign sKS/2
 285 # 5  <1> leavesub[1 ref] K/REFC,1
 286 EONT_EONT
 287
 288 checkOptree ( name      => 'sub {our $a=()}',
 289               code      => sub {our $a=()},
 290               #todo     => 'probly not worth doing',
 291               bcopts    => '-exec',
 292               @open_todo,
 293               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 294 1  <;> nextstate(main 31 optree.t:177) v:{
 295 2  <0> stub sP
 296 3  <#> gvsv[*a] s/OURINTR
 297 4  <2> sassign sKS/2
 298 5  <1> leavesub[1 ref] K/REFC,1
 299 EOT_EOT
 300 # 1  <;> nextstate(main 440 optree_varinit.t:262) v:{
 301 # 2  <0> stub sP
 302 # 3  <$> gvsv(*a) s/OURINTR
 303 # 4  <2> sassign sKS/2
 304 # 5  <1> leavesub[1 ref] K/REFC,1
 305 EONT_EONT
 306
 307 checkOptree ( name      => 'sub {local $a=()}',
 308               code      => sub {local $a=()},
 309               #todo     => 'probly not worth doing',
 310               bcopts    => '-exec',
 311               @open_todo,
 312               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 313 1  <;> nextstate(main 33 optree.t:190) v:{
 314 2  <0> stub sP
 315 3  <#> gvsv[*a] s/LVINTRO
 316 4  <2> sassign sKS/2
 317 5  <1> leavesub[1 ref] K/REFC,1
 318 EOT_EOT
 319 # 1  <;> nextstate(main 63 optree.t:225) v:{
 320 # 2  <0> stub sP
 321 # 3  <$> gvsv(*a) s/LVINTRO
 322 # 4  <2> sassign sKS/2
 323 # 5  <1> leavesub[1 ref] K/REFC,1
 324 EONT_EONT
 325
 326 checkOptree ( name      => 'my $a=()',
 327               prog      => 'my $a=()',
 328               bcopts    => '-exec',
 329               @open_todo,
 330               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 331 1  <0> enter
 332 2  <;> nextstate(main 1 -e:1) v:{
 333 3  <0> stub sP
 334 4  <0> padsv[$a:1,2] sRM*/LVINTRO
 335 5  <2> sassign vKS/2
 336 6  <@> leave[1 ref] vKP/REFC
 337 EOT_EOT
 338 # 1  <0> enter
 339 # 2  <;> nextstate(main 1 -e:1) v:{
 340 # 3  <0> stub sP
 341 # 4  <0> padsv[$a:1,2] sRM*/LVINTRO
 342 # 5  <2> sassign vKS/2
 343 # 6  <@> leave[1 ref] vKP/REFC
 344 EONT_EONT
 345
 346 checkOptree ( name      => 'our $a=()',
 347               prog      => 'our $a=()',
 348               #todo     => 'probly not worth doing',
 349               bcopts    => '-exec',
 350               @open_todo,
 351               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 352 1  <0> enter
 353 2  <;> nextstate(main 1 -e:1) v:{
 354 3  <0> stub sP
 355 4  <#> gvsv[*a] s/OURINTR
 356 5  <2> sassign vKS/2
 357 6  <@> leave[1 ref] vKP/REFC
 358 EOT_EOT
 359 # 1  <0> enter
 360 # 2  <;> nextstate(main 1 -e:1) v:{
 361 # 3  <0> stub sP
 362 # 4  <$> gvsv(*a) s/OURINTR
 363 # 5  <2> sassign vKS/2
 364 # 6  <@> leave[1 ref] vKP/REFC
 365 EONT_EONT
 366
 367 checkOptree ( name      => 'local $a=()',
 368               prog      => 'local $a=()',
 369               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 370               #todo     => 'probly not worth doing',
 371               bcopts    => '-exec',
 372               @open_todo,
 373               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 374 1  <0> enter
 375 2  <;> nextstate(main 1 -e:1) v:{
 376 3  <0> stub sP
 377 4  <#> gvsv[*a] s/LVINTRO
 378 5  <2> sassign vKS/2
 379 6  <@> leave[1 ref] vKP/REFC
 380 EOT_EOT
 381 # 1  <0> enter
 382 # 2  <;> nextstate(main 1 -e:1) v:{
 383 # 3  <0> stub sP
 384 # 4  <$> gvsv(*a) s/LVINTRO
 385 # 5  <2> sassign vKS/2
 386 # 6  <@> leave[1 ref] vKP/REFC
 387 EONT_EONT
 388
 389 checkOptree ( name      => 'my ($a,$b)=()',
 390               prog      => 'my ($a,$b)=()',
 391               #todo     => 'probly not worth doing',
 392               bcopts    => '-exec',
 393               @open_todo,
 394               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 395 # 1  <0> enter
 396 # 2  <;> nextstate(main 1 -e:1) v:{
 397 # 3  <0> pushmark s
 398 # 4  <0> pushmark sRM*/128
 399 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 400 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 401 # 7  <2> aassign[t3] vKS
 402 # 8  <@> leave[1 ref] vKP/REFC
 403 EOT_EOT
 404 # 1  <0> enter
 405 # 2  <;> nextstate(main 1 -e:1) v:{
 406 # 3  <0> pushmark s
 407 # 4  <0> pushmark sRM*/128
 408 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 409 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 410 # 7  <2> aassign[t3] vKS
 411 # 8  <@> leave[1 ref] vKP/REFC
 412 EONT_EONT
 413
 414 } #skip
 415
 416 __END__
 417