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               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               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 113               bcopts    => '-basic',
 114               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 115 4  <@> leave[1 ref] vKP/REFC ->(end)
 116 1     <0> enter ->2
 117 2     <;> nextstate(main 1 -e:1) v ->3
 118 -     <1> ex-rv2sv vKM/129 ->4
 119 3        <#> gvsv[*a] s/LVINTRO ->4
 120 EOT_EOT
 121 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 122 # 1     <0> enter ->2
 123 # 2     <;> nextstate(main 1 -e:1) v ->3
 124 # -     <1> ex-rv2sv vKM/129 ->4
 125 # 3        <$> gvsv(*a) s/LVINTRO ->4
 126 EONT_EONT
 127
 128 pass("MY, OUR, LOCAL, BOTH SUB AND MAIN, = undef");
 129
 130 checkOptree ( name      => 'sub {my $a=undef}',
 131               code      => sub {my $a=undef},
 132               bcopts    => '-basic',
 133               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 134 3  <1> leavesub[1 ref] K/REFC,1 ->(end)
 135 -     <@> lineseq KP ->3
 136 1        <;> nextstate(main 24 optree.t:99) v ->2
 137 2        <0> padsv[$a:24,25] sRM*/LVINTRO ->3
 138 EOT_EOT
 139 # 3  <1> leavesub[1 ref] K/REFC,1 ->(end)
 140 # -     <@> lineseq KP ->3
 141 # 1        <;> nextstate(main 54 optree.t:149) v ->2
 142 # 2        <0> padsv[$a:54,55] sRM*/LVINTRO ->3
 143 EONT_EONT
 144
 145 checkOptree ( name      => 'sub {our $a=undef}',
 146               code      => sub {our $a=undef},
 147               note      => 'the global must be reset',
 148               bcopts    => '-basic',
 149               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 150 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 151 -     <@> lineseq KP ->5
 152 1        <;> nextstate(main 26 optree.t:109) v ->2
 153 4        <2> sassign sKS/2 ->5
 154 2           <0> undef s ->3
 155 -           <1> ex-rv2sv sKRM*/17 ->4
 156 3              <#> gvsv[*a] s/OURINTR ->4
 157 EOT_EOT
 158 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 159 # -     <@> lineseq KP ->5
 160 # 1        <;> nextstate(main 446 optree_varinit.t:137) v ->2
 161 # 4        <2> sassign sKS/2 ->5
 162 # 2           <0> undef s ->3
 163 # -           <1> ex-rv2sv sKRM*/17 ->4
 164 # 3              <$> gvsv(*a) s/OURINTR ->4
 165 EONT_EONT
 166
 167 checkOptree ( name      => 'sub {local $a=undef}',
 168               code      => sub {local $a=undef},
 169               note      => 'local not used enough to bother',
 170               bcopts    => '-basic',
 171               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 172 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 173 -     <@> lineseq KP ->5
 174 1        <;> nextstate(main 28 optree.t:122) v ->2
 175 4        <2> sassign sKS/2 ->5
 176 2           <0> undef s ->3
 177 -           <1> ex-rv2sv sKRM*/129 ->4
 178 3              <#> gvsv[*a] s/LVINTRO ->4
 179 EOT_EOT
 180 # 5  <1> leavesub[1 ref] K/REFC,1 ->(end)
 181 # -     <@> lineseq KP ->5
 182 # 1        <;> nextstate(main 58 optree.t:141) v ->2
 183 # 4        <2> sassign sKS/2 ->5
 184 # 2           <0> undef s ->3
 185 # -           <1> ex-rv2sv sKRM*/129 ->4
 186 # 3              <$> gvsv(*a) s/LVINTRO ->4
 187 EONT_EONT
 188
 189 checkOptree ( name      => 'my $a=undef',
 190               prog      => 'my $a=undef',
 191               bcopts    => '-basic',
 192               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 193 4  <@> leave[1 ref] vKP/REFC ->(end)
 194 1     <0> enter ->2
 195 2     <;> nextstate(main 1 -e:1) v ->3
 196 3     <0> padsv[$a:1,2] vRM*/LVINTRO ->4
 197 EOT_EOT
 198 # 4  <@> leave[1 ref] vKP/REFC ->(end)
 199 # 1     <0> enter ->2
 200 # 2     <;> nextstate(main 1 -e:1) v ->3
 201 # 3     <0> padsv[$a:1,2] vRM*/LVINTRO ->4
 202 EONT_EONT
 203
 204 checkOptree ( name      => 'our $a=undef',
 205               prog      => 'our $a=undef',
 206               note      => 'global must be reassigned',
 207               bcopts    => '-basic',
 208               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 209 6  <@> leave[1 ref] vKP/REFC ->(end)
 210 1     <0> enter ->2
 211 2     <;> nextstate(main 1 -e:1) v ->3
 212 5     <2> sassign vKS/2 ->6
 213 3        <0> undef s ->4
 214 -        <1> ex-rv2sv sKRM*/17 ->5
 215 4           <#> gvsv[*a] s/OURINTR ->5
 216 EOT_EOT
 217 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 218 # 1     <0> enter ->2
 219 # 2     <;> nextstate(main 1 -e:1) v ->3
 220 # 5     <2> sassign vKS/2 ->6
 221 # 3        <0> undef s ->4
 222 # -        <1> ex-rv2sv sKRM*/17 ->5
 223 # 4           <$> gvsv(*a) s/OURINTR ->5
 224 EONT_EONT
 225
 226 checkOptree ( name      => 'local $a=undef',
 227               prog      => 'local $a=undef',
 228               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 229               note      => 'locals are rare, probly not worth doing',
 230               bcopts    => '-basic',
 231               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 232 6  <@> leave[1 ref] vKP/REFC ->(end)
 233 1     <0> enter ->2
 234 2     <;> nextstate(main 1 -e:1) v ->3
 235 5     <2> sassign vKS/2 ->6
 236 3        <0> undef s ->4
 237 -        <1> ex-rv2sv sKRM*/129 ->5
 238 4           <#> gvsv[*a] s/LVINTRO ->5
 239 EOT_EOT
 240 # 6  <@> leave[1 ref] vKP/REFC ->(end)
 241 # 1     <0> enter ->2
 242 # 2     <;> nextstate(main 1 -e:1) v ->3
 243 # 5     <2> sassign vKS/2 ->6
 244 # 3        <0> undef s ->4
 245 # -        <1> ex-rv2sv sKRM*/129 ->5
 246 # 4           <$> gvsv(*a) s/LVINTRO ->5
 247 EONT_EONT
 248
 249 checkOptree ( name      => 'sub {my $a=()}',
 250               code      => sub {my $a=()},
 251               bcopts    => '-exec',
 252               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 253 1  <;> nextstate(main -439 optree.t:105) v
 254 2  <0> stub sP
 255 3  <0> padsv[$a:-439,-438] sRM*/LVINTRO
 256 4  <2> sassign sKS/2
 257 5  <1> leavesub[1 ref] K/REFC,1
 258 EOT_EOT
 259 # 1  <;> nextstate(main 438 optree_varinit.t:247) v
 260 # 2  <0> stub sP
 261 # 3  <0> padsv[$a:438,439] sRM*/LVINTRO
 262 # 4  <2> sassign sKS/2
 263 # 5  <1> leavesub[1 ref] K/REFC,1
 264 EONT_EONT
 265
 266 checkOptree ( name      => 'sub {our $a=()}',
 267               code      => sub {our $a=()},
 268               #todo     => 'probly not worth doing',
 269               bcopts    => '-exec',
 270               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 271 1  <;> nextstate(main 31 optree.t:177) v
 272 2  <0> stub sP
 273 3  <#> gvsv[*a] s/OURINTR
 274 4  <2> sassign sKS/2
 275 5  <1> leavesub[1 ref] K/REFC,1
 276 EOT_EOT
 277 # 1  <;> nextstate(main 440 optree_varinit.t:262) v
 278 # 2  <0> stub sP
 279 # 3  <$> gvsv(*a) s/OURINTR
 280 # 4  <2> sassign sKS/2
 281 # 5  <1> leavesub[1 ref] K/REFC,1
 282 EONT_EONT
 283
 284 checkOptree ( name      => 'sub {local $a=()}',
 285               code      => sub {local $a=()},
 286               #todo     => 'probly not worth doing',
 287               bcopts    => '-exec',
 288               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 289 1  <;> nextstate(main 33 optree.t:190) v
 290 2  <0> stub sP
 291 3  <#> gvsv[*a] s/LVINTRO
 292 4  <2> sassign sKS/2
 293 5  <1> leavesub[1 ref] K/REFC,1
 294 EOT_EOT
 295 # 1  <;> nextstate(main 63 optree.t:225) v
 296 # 2  <0> stub sP
 297 # 3  <$> gvsv(*a) s/LVINTRO
 298 # 4  <2> sassign sKS/2
 299 # 5  <1> leavesub[1 ref] K/REFC,1
 300 EONT_EONT
 301
 302 checkOptree ( name      => 'my $a=()',
 303               prog      => 'my $a=()',
 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               errs      => ['Name "main::a" used only once: possible typo at -e line 1.'],
 344               #todo     => 'probly not worth doing',
 345               bcopts    => '-exec',
 346               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 347 1  <0> enter
 348 2  <;> nextstate(main 1 -e:1) v
 349 3  <0> stub sP
 350 4  <#> gvsv[*a] s/LVINTRO
 351 5  <2> sassign vKS/2
 352 6  <@> leave[1 ref] vKP/REFC
 353 EOT_EOT
 354 # 1  <0> enter
 355 # 2  <;> nextstate(main 1 -e:1) v
 356 # 3  <0> stub sP
 357 # 4  <$> gvsv(*a) s/LVINTRO
 358 # 5  <2> sassign vKS/2
 359 # 6  <@> leave[1 ref] vKP/REFC
 360 EONT_EONT
 361
 362 checkOptree ( name      => 'my ($a,$b)=()',
 363               prog      => 'my ($a,$b)=()',
 364               #todo     => 'probly not worth doing',
 365               bcopts    => '-exec',
 366               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 367 # 1  <0> enter
 368 # 2  <;> nextstate(main 1 -e:1) v
 369 # 3  <0> pushmark s
 370 # 4  <0> pushmark sRM*/128
 371 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 372 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 373 # 7  <2> aassign[t3] vKS
 374 # 8  <@> leave[1 ref] vKP/REFC
 375 EOT_EOT
 376 # 1  <0> enter
 377 # 2  <;> nextstate(main 1 -e:1) v
 378 # 3  <0> pushmark s
 379 # 4  <0> pushmark sRM*/128
 380 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 381 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 382 # 7  <2> aassign[t3] vKS
 383 # 8  <@> leave[1 ref] vKP/REFC
 384 EONT_EONT
 385
 386 } #skip
 387
 388 __END__
 389