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               bcopts    => '-exec',
 250               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 251 1  <;> nextstate(main -439 optree.t:105) v
 252 2  <0> stub sP
 253 3  <0> padsv[$a:-439,-438] sRM*/LVINTRO
 254 4  <2> sassign sKS/2
 255 5  <1> leavesub[1 ref] K/REFC,1
 256 EOT_EOT
 257 # 1  <;> nextstate(main 438 optree_varinit.t:247) v
 258 # 2  <0> stub sP
 259 # 3  <0> padsv[$a:438,439] sRM*/LVINTRO
 260 # 4  <2> sassign sKS/2
 261 # 5  <1> leavesub[1 ref] K/REFC,1
 262 EONT_EONT
 263
 264 checkOptree ( name      => 'sub {our $a=()}',
 265               code      => sub {our $a=()},
 266               #todo     => 'probly not worth doing',
 267               bcopts    => '-exec',
 268               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 269 1  <;> nextstate(main 31 optree.t:177) v
 270 2  <0> stub sP
 271 3  <#> gvsv[*a] s/OURINTR
 272 4  <2> sassign sKS/2
 273 5  <1> leavesub[1 ref] K/REFC,1
 274 EOT_EOT
 275 # 1  <;> nextstate(main 440 optree_varinit.t:262) v
 276 # 2  <0> stub sP
 277 # 3  <$> gvsv(*a) s/OURINTR
 278 # 4  <2> sassign sKS/2
 279 # 5  <1> leavesub[1 ref] K/REFC,1
 280 EONT_EONT
 281
 282 checkOptree ( name      => 'sub {local $a=()}',
 283               code      => sub {local $a=()},
 284               #todo     => 'probly not worth doing',
 285               bcopts    => '-exec',
 286               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 287 1  <;> nextstate(main 33 optree.t:190) v
 288 2  <0> stub sP
 289 3  <#> gvsv[*a] s/LVINTRO
 290 4  <2> sassign sKS/2
 291 5  <1> leavesub[1 ref] K/REFC,1
 292 EOT_EOT
 293 # 1  <;> nextstate(main 63 optree.t:225) v
 294 # 2  <0> stub sP
 295 # 3  <$> gvsv(*a) s/LVINTRO
 296 # 4  <2> sassign sKS/2
 297 # 5  <1> leavesub[1 ref] K/REFC,1
 298 EONT_EONT
 299
 300 checkOptree ( name      => 'my $a=()',
 301               prog      => 'my $a=()',
 302               bcopts    => '-exec',
 303               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 304 1  <0> enter
 305 2  <;> nextstate(main 1 -e:1) v
 306 3  <0> stub sP
 307 4  <0> padsv[$a:1,2] sRM*/LVINTRO
 308 5  <2> sassign vKS/2
 309 6  <@> leave[1 ref] vKP/REFC
 310 EOT_EOT
 311 # 1  <0> enter
 312 # 2  <;> nextstate(main 1 -e:1) v
 313 # 3  <0> stub sP
 314 # 4  <0> padsv[$a:1,2] sRM*/LVINTRO
 315 # 5  <2> sassign vKS/2
 316 # 6  <@> leave[1 ref] vKP/REFC
 317 EONT_EONT
 318
 319 checkOptree ( name      => 'our $a=()',
 320               prog      => 'our $a=()',
 321               #todo     => 'probly not worth doing',
 322               bcopts    => '-exec',
 323               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 324 1  <0> enter
 325 2  <;> nextstate(main 1 -e:1) v
 326 3  <0> stub sP
 327 4  <#> gvsv[*a] s/OURINTR
 328 5  <2> sassign vKS/2
 329 6  <@> leave[1 ref] vKP/REFC
 330 EOT_EOT
 331 # 1  <0> enter
 332 # 2  <;> nextstate(main 1 -e:1) v
 333 # 3  <0> stub sP
 334 # 4  <$> gvsv(*a) s/OURINTR
 335 # 5  <2> sassign vKS/2
 336 # 6  <@> leave[1 ref] vKP/REFC
 337 EONT_EONT
 338
 339 checkOptree ( name      => 'local $a=()',
 340               prog      => 'local $a=()',
 341               #todo     => 'probly not worth doing',
 342               bcopts    => '-exec',
 343               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 344 1  <0> enter
 345 2  <;> nextstate(main 1 -e:1) v
 346 3  <0> stub sP
 347 4  <#> gvsv[*a] s/LVINTRO
 348 5  <2> sassign vKS/2
 349 6  <@> leave[1 ref] vKP/REFC
 350 EOT_EOT
 351 # 1  <0> enter
 352 # 2  <;> nextstate(main 1 -e:1) v
 353 # 3  <0> stub sP
 354 # 4  <$> gvsv(*a) s/LVINTRO
 355 # 5  <2> sassign vKS/2
 356 # 6  <@> leave[1 ref] vKP/REFC
 357 EONT_EONT
 358
 359 checkOptree ( name      => 'my ($a,$b)=()',
 360               prog      => 'my ($a,$b)=()',
 361               #todo     => 'probly not worth doing',
 362               bcopts    => '-exec',
 363               expect    => <<'EOT_EOT', expect_nt => <<'EONT_EONT');
 364 # 1  <0> enter
 365 # 2  <;> nextstate(main 1 -e:1) v
 366 # 3  <0> pushmark s
 367 # 4  <0> pushmark sRM*/128
 368 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 369 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 370 # 7  <2> aassign[t3] vKS
 371 # 8  <@> leave[1 ref] vKP/REFC
 372 EOT_EOT
 373 # 1  <0> enter
 374 # 2  <;> nextstate(main 1 -e:1) v
 375 # 3  <0> pushmark s
 376 # 4  <0> pushmark sRM*/128
 377 # 5  <0> padsv[$a:1,2] lRM*/LVINTRO
 378 # 6  <0> padsv[$b:1,2] lRM*/LVINTRO
 379 # 7  <2> aassign[t3] vKS
 380 # 8  <@> leave[1 ref] vKP/REFC
 381 EONT_EONT
 382
 383 } #skip
 384
 385 __END__
 386