Anonymous avatar Anonymous committed 31eb43f

support exeunt with mandative list

Comments (0)

Files changed (7)

src/builtins/say.pir

     print "enter\n"
     .return ()
 .end
+.sub 'exeunt'
+    .param pmc args :slurpy
+    print "exeunt\n"
+    .return ()
+.end
 .sub 'say2'
     print "hello\n"
     .return ()

src/gen_actions.pir

 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block13" :init :load :subid("42")
-    .const 'Sub' $P422 = "40" 
-    capture_lex $P422
-    .const 'Sub' $P405 = "39" 
-    capture_lex $P405
-    .const 'Sub' $P393 = "38" 
+.sub "_block13" :init :load :subid("45")
+    .const 'Sub' $P456 = "43" 
+    capture_lex $P456
+    .const 'Sub' $P439 = "42" 
+    capture_lex $P439
+    .const 'Sub' $P427 = "41" 
+    capture_lex $P427
+    .const 'Sub' $P408 = "40" 
+    capture_lex $P408
+    .const 'Sub' $P393 = "39" 
     capture_lex $P393
-    .const 'Sub' $P374 = "37" 
-    capture_lex $P374
-    .const 'Sub' $P359 = "36" 
-    capture_lex $P359
-    .const 'Sub' $P344 = "35" 
-    capture_lex $P344
+    .const 'Sub' $P378 = "38" 
+    capture_lex $P378
+    .const 'Sub' $P341 = "34" 
+    capture_lex $P341
     .const 'Sub' $P307 = "31" 
     capture_lex $P307
     .const 'Sub' $P278 = "29" 
         $P2 = $P0.'new_class'($P1)
       subclass_done:
         pop_eh
-    .const 'Sub' $P422 = "40" 
-    capture_lex $P422
-    .return ($P422)
+    .const 'Sub' $P456 = "43" 
+    capture_lex $P456
+    .return ($P456)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "TOP"  :subid("11") :method :outer("42")
+.sub "TOP"  :subid("11") :method :outer("45")
     .param pmc param_18
     new $P17, 'ExceptionHandler'
     set_addr $P17, control_16
     .lex "$/", param_18
     get_hll_global $P19, ["PAST"], "Block"
     find_lex $P20, "$/"
-    unless_null $P20, vivify_43
+    unless_null $P20, vivify_46
     new $P20, "Undef"
-  vivify_43:
+  vivify_46:
     $P21 = $P19."new"($P20 :named("node"))
     .lex "$past", $P21
     get_hll_global $P22, ["PAST"], "Var"
     find_lex $P23, "$/"
-    unless_null $P23, vivify_44
+    unless_null $P23, vivify_47
     new $P23, "Undef"
-  vivify_44:
+  vivify_47:
     $P24 = $P22."new"("the_condition" :named("name"), 1 :named("isdecl"), "package" :named("scope"), $P23 :named("node"))
     .lex "$tc", $P24
     find_lex $P25, "$past"
-    unless_null $P25, vivify_45
+    unless_null $P25, vivify_48
     new $P25, "Undef"
-  vivify_45:
+  vivify_48:
     find_lex $P26, "$tc"
-    unless_null $P26, vivify_46
+    unless_null $P26, vivify_49
     new $P26, "Undef"
-  vivify_46:
+  vivify_49:
     $P25."push"($P26)
     find_lex $P28, "$/"
     set $P29, $P28["scene"]
-    unless_null $P29, vivify_47
+    unless_null $P29, vivify_50
     new $P29, "Undef"
-  vivify_47:
+  vivify_50:
     defined $I30, $P29
-    unless $I30, for_undef_48
+    unless $I30, for_undef_51
     iter $P27, $P29
     new $P40, 'ExceptionHandler'
     set_addr $P40, loop39_handler
     eq $P41, 66, loop39_redo
   loop39_done:
     pop_eh 
-  for_undef_48:
+  for_undef_51:
     find_lex $P42, "$/"
     find_lex $P43, "$past"
-    unless_null $P43, vivify_51
+    unless_null $P43, vivify_54
     new $P43, "Undef"
-  vivify_51:
+  vivify_54:
     $P44 = $P42."result_object"($P43)
     .return ($P44)
   control_16:
     .param pmc param_34
     .lex "$_", param_34
     find_lex $P35, "$past"
-    unless_null $P35, vivify_49
+    unless_null $P35, vivify_52
     new $P35, "Undef"
-  vivify_49:
+  vivify_52:
     find_lex $P36, "$_"
-    unless_null $P36, vivify_50
+    unless_null $P36, vivify_53
     new $P36, "Undef"
-  vivify_50:
+  vivify_53:
     $P37 = $P36."item"()
     $P38 = $P35."push"($P37)
     .return ($P38)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "events"  :subid("13") :method :outer("42")
+.sub "events"  :subid("13") :method :outer("45")
     .param pmc param_49
     .param pmc param_50
     new $P48, 'ExceptionHandler'
     new $P51, "String"
     assign $P51, "evs:"
     find_lex $P52, "$k"
-    unless_null $P52, vivify_52
+    unless_null $P52, vivify_55
     new $P52, "Undef"
-  vivify_52:
+  vivify_55:
     concat $P53, $P51, $P52
     "dbg"($P53)
     find_lex $P54, "$/"
     find_lex $P55, "$k"
-    unless_null $P55, vivify_53
+    unless_null $P55, vivify_56
     new $P55, "Undef"
-  vivify_53:
+  vivify_56:
     find_lex $P56, "$/"
-    unless_null $P56, vivify_54
+    unless_null $P56, vivify_57
     new $P56, "Hash"
-  vivify_54:
+  vivify_57:
     set $P57, $P56[$P55]
-    unless_null $P57, vivify_55
+    unless_null $P57, vivify_58
     new $P57, "Undef"
-  vivify_55:
+  vivify_58:
     $P58 = $P57."item"()
     $P59 = $P54."result_object"($P58)
     .return ($P59)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "scene"  :subid("14") :method :outer("42")
+.sub "scene"  :subid("14") :method :outer("45")
     .param pmc param_64
     new $P63, 'ExceptionHandler'
     set_addr $P63, control_62
     get_hll_global $P65, ["PAST"], "Stmts"
     find_lex $P66, "$/"
     set $P67, $P66["roman"]
-    unless_null $P67, vivify_56
+    unless_null $P67, vivify_59
     new $P67, "Undef"
-  vivify_56:
+  vivify_59:
     find_lex $P68, "$/"
-    unless_null $P68, vivify_57
+    unless_null $P68, vivify_60
     new $P68, "Undef"
-  vivify_57:
+  vivify_60:
     $P69 = $P65."new"($P67 :named("name"), $P68 :named("node"))
     .lex "$past", $P69
     get_hll_global $P70, ["PAST"], "Op"
     assign $P71, ""
     find_lex $P72, "$/"
     set $P73, $P72["roman"]
-    unless_null $P73, vivify_58
+    unless_null $P73, vivify_61
     new $P73, "Undef"
-  vivify_58:
+  vivify_61:
     concat $P74, $P71, $P73
     concat $P75, $P74, ":"
     find_lex $P76, "$/"
-    unless_null $P76, vivify_59
+    unless_null $P76, vivify_62
     new $P76, "Undef"
-  vivify_59:
+  vivify_62:
     $P77 = $P70."new"($P75 :named("inline"), $P76 :named("node"))
     .lex "$lbl", $P77
     find_lex $P78, "$past"
-    unless_null $P78, vivify_60
+    unless_null $P78, vivify_63
     new $P78, "Undef"
-  vivify_60:
+  vivify_63:
     find_lex $P79, "$lbl"
-    unless_null $P79, vivify_61
+    unless_null $P79, vivify_64
     new $P79, "Undef"
-  vivify_61:
+  vivify_64:
     $P78."push"($P79)
     find_lex $P81, "$/"
     set $P82, $P81["events"]
-    unless_null $P82, vivify_62
+    unless_null $P82, vivify_65
     new $P82, "Undef"
-  vivify_62:
+  vivify_65:
     defined $I83, $P82
-    unless $I83, for_undef_63
+    unless $I83, for_undef_66
     iter $P80, $P82
     new $P93, 'ExceptionHandler'
     set_addr $P93, loop92_handler
     eq $P94, 66, loop92_redo
   loop92_done:
     pop_eh 
-  for_undef_63:
+  for_undef_66:
     find_lex $P95, "$/"
     find_lex $P96, "$past"
-    unless_null $P96, vivify_66
+    unless_null $P96, vivify_69
     new $P96, "Undef"
-  vivify_66:
+  vivify_69:
     $P97 = $P95."result_object"($P96)
     .return ($P97)
   control_62:
     .param pmc param_87
     .lex "$_", param_87
     find_lex $P88, "$past"
-    unless_null $P88, vivify_64
+    unless_null $P88, vivify_67
     new $P88, "Undef"
-  vivify_64:
+  vivify_67:
     find_lex $P89, "$_"
-    unless_null $P89, vivify_65
+    unless_null $P89, vivify_68
     new $P89, "Undef"
-  vivify_65:
+  vivify_68:
     $P90 = $P89."item"()
     $P91 = $P88."push"($P90)
     .return ($P91)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "branch"  :subid("16") :method :outer("42")
+.sub "branch"  :subid("16") :method :outer("45")
     .param pmc param_102
     new $P101, 'ExceptionHandler'
     set_addr $P101, control_100
     assign $P103, "branch:"
     find_lex $P104, "$/"
     set $P105, $P104["roman"]
-    unless_null $P105, vivify_67
+    unless_null $P105, vivify_70
     new $P105, "Undef"
-  vivify_67:
+  vivify_70:
     concat $P106, $P103, $P105
     "dbg"($P106)
     get_hll_global $P107, ["PAST"], "Op"
     assign $P108, "goto "
     find_lex $P109, "$/"
     set $P110, $P109["roman"]
-    unless_null $P110, vivify_68
+    unless_null $P110, vivify_71
     new $P110, "Undef"
-  vivify_68:
+  vivify_71:
     concat $P111, $P108, $P110
     find_lex $P112, "$/"
-    unless_null $P112, vivify_69
+    unless_null $P112, vivify_72
     new $P112, "Undef"
-  vivify_69:
+  vivify_72:
     $P113 = $P107."new"($P111 :named("inline"), $P112 :named("node"))
     .lex "$res", $P113
     find_lex $P114, "$/"
     find_lex $P115, "$res"
-    unless_null $P115, vivify_70
+    unless_null $P115, vivify_73
     new $P115, "Undef"
-  vivify_70:
+  vivify_73:
     $P116 = $P114."result_object"($P115)
     .return ($P116)
   control_100:
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "io"  :subid("17") :method :outer("42")
+.sub "io"  :subid("17") :method :outer("45")
     .param pmc param_121
     .param pmc param_122
     new $P120, 'ExceptionHandler'
     new $P123, "String"
     assign $P123, "io:"
     find_lex $P124, "$key"
-    unless_null $P124, vivify_71
+    unless_null $P124, vivify_74
     new $P124, "Undef"
-  vivify_71:
+  vivify_74:
     concat $P125, $P123, $P124
     "dbg"($P125)
     get_hll_global $P126, ["PAST"], "Op"
     find_lex $P127, "$/"
-    unless_null $P127, vivify_72
+    unless_null $P127, vivify_75
     new $P127, "Undef"
-  vivify_72:
+  vivify_75:
     $P128 = $P126."new"("say2" :named("name"), "call" :named("pasttype"), $P127 :named("node"))
     .lex "$res", $P128
     "dbg"("ok")
     find_lex $P129, "$/"
     find_lex $P130, "$res"
-    unless_null $P130, vivify_73
+    unless_null $P130, vivify_76
     new $P130, "Undef"
-  vivify_73:
+  vivify_76:
     $P131 = $P129."result_object"($P130)
     .return ($P131)
   control_119:
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "line"  :subid("18") :method :outer("42")
+.sub "line"  :subid("18") :method :outer("45")
     .param pmc param_136
     new $P135, 'ExceptionHandler'
     set_addr $P135, control_134
     "dbg"("line:")
     get_hll_global $P137, ["PAST"], "Stmts"
     find_lex $P138, "$/"
-    unless_null $P138, vivify_74
+    unless_null $P138, vivify_77
     new $P138, "Undef"
-  vivify_74:
+  vivify_77:
     $P139 = $P137."new"($P138 :named("node"))
     .lex "$past", $P139
     find_lex $P141, "$/"
     set $P142, $P141["sentence"]
-    unless_null $P142, vivify_75
+    unless_null $P142, vivify_78
     new $P142, "Undef"
-  vivify_75:
+  vivify_78:
     defined $I143, $P142
-    unless $I143, for_undef_76
+    unless $I143, for_undef_79
     iter $P140, $P142
     new $P153, 'ExceptionHandler'
     set_addr $P153, loop152_handler
     eq $P154, 66, loop152_redo
   loop152_done:
     pop_eh 
-  for_undef_76:
+  for_undef_79:
     find_lex $P155, "$/"
     find_lex $P156, "$past"
-    unless_null $P156, vivify_79
+    unless_null $P156, vivify_82
     new $P156, "Undef"
-  vivify_79:
+  vivify_82:
     $P157 = $P155."result_object"($P156)
     .return ($P157)
   control_134:
     .param pmc param_147
     .lex "$_", param_147
     find_lex $P148, "$past"
-    unless_null $P148, vivify_77
+    unless_null $P148, vivify_80
     new $P148, "Undef"
-  vivify_77:
+  vivify_80:
     find_lex $P149, "$_"
-    unless_null $P149, vivify_78
+    unless_null $P149, vivify_81
     new $P149, "Undef"
-  vivify_78:
+  vivify_81:
     $P150 = $P149."item"()
     $P151 = $P148."push"($P150)
     .return ($P151)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "sentence"  :subid("20") :method :outer("42")
+.sub "sentence"  :subid("20") :method :outer("45")
     .param pmc param_162
     .param pmc param_163
     new $P161, 'ExceptionHandler'
     new $P164, "String"
     assign $P164, "sentence:"
     find_lex $P165, "$key"
-    unless_null $P165, vivify_80
+    unless_null $P165, vivify_83
     new $P165, "Undef"
-  vivify_80:
+  vivify_83:
     concat $P166, $P164, $P165
     "dbg"($P166)
     find_lex $P167, "$/"
     find_lex $P168, "$key"
-    unless_null $P168, vivify_81
+    unless_null $P168, vivify_84
     new $P168, "Undef"
-  vivify_81:
+  vivify_84:
     find_lex $P169, "$/"
-    unless_null $P169, vivify_82
+    unless_null $P169, vivify_85
     new $P169, "Hash"
-  vivify_82:
+  vivify_85:
     set $P170, $P169[$P168]
-    unless_null $P170, vivify_83
+    unless_null $P170, vivify_86
     new $P170, "Undef"
-  vivify_83:
+  vivify_86:
     $P171 = $P170."item"()
     $P172 = $P167."result_object"($P171)
     .return ($P172)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "dbg"  :subid("21") :outer("42")
+.sub "dbg"  :subid("21") :outer("45")
     .param pmc param_177
     new $P176, 'ExceptionHandler'
     set_addr $P176, control_175
 .namespace ["z2";"Grammar";"Actions"]
 .sub "_block181"  :anon :subid("22") :outer("21")
     find_lex $P183, "$str"
-    unless_null $P183, vivify_84
+    unless_null $P183, vivify_87
     new $P183, "Undef"
-  vivify_84:
+  vivify_87:
     $P184 = "say"($P183)
     .return ($P184)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "value"  :subid("23") :method :outer("42")
+.sub "value"  :subid("23") :method :outer("45")
     .param pmc param_190
     .param pmc param_191
     new $P189, 'ExceptionHandler'
     .lex "$key", param_191
     find_lex $P192, "$/"
     find_lex $P193, "$key"
-    unless_null $P193, vivify_85
+    unless_null $P193, vivify_88
     new $P193, "Undef"
-  vivify_85:
+  vivify_88:
     find_lex $P194, "$/"
-    unless_null $P194, vivify_86
+    unless_null $P194, vivify_89
     new $P194, "Hash"
-  vivify_86:
+  vivify_89:
     set $P195, $P194[$P193]
-    unless_null $P195, vivify_87
+    unless_null $P195, vivify_90
     new $P195, "Undef"
-  vivify_87:
+  vivify_90:
     $P196 = $P195."item"()
     $P197 = $P192."result_object"($P196)
     .return ($P197)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "question"  :subid("24") :method :outer("42")
+.sub "question"  :subid("24") :method :outer("45")
     .param pmc param_202
     .param pmc param_203
     new $P201, 'ExceptionHandler'
     assign $P204, "question:"
     find_lex $P205, "$/"
     set $P206, $P205["key"]
-    unless_null $P206, vivify_88
+    unless_null $P206, vivify_91
     new $P206, "Undef"
-  vivify_88:
+  vivify_91:
     concat $P207, $P204, $P206
     "dbg"($P207)
     get_hll_global $P208, ["PAST"], "Op"
     assign $P209, "goto "
     find_lex $P210, "$/"
     set $P211, $P210["roman"]
-    unless_null $P211, vivify_89
+    unless_null $P211, vivify_92
     new $P211, "Undef"
-  vivify_89:
+  vivify_92:
     concat $P212, $P209, $P211
     find_lex $P213, "$/"
-    unless_null $P213, vivify_90
+    unless_null $P213, vivify_93
     new $P213, "Undef"
-  vivify_90:
+  vivify_93:
     $P214 = $P208."new"($P212 :named("inline"), $P213 :named("node"))
     .lex "$res", $P214
     find_lex $P215, "$/"
     find_lex $P216, "$res"
-    unless_null $P216, vivify_91
+    unless_null $P216, vivify_94
     new $P216, "Undef"
-  vivify_91:
+  vivify_94:
     $P215."result_object"($P216)
     get_hll_global $P217, ["PAST"], "Op"
     find_lex $P218, "$key"
-    unless_null $P218, vivify_92
+    unless_null $P218, vivify_95
     new $P218, "Undef"
-  vivify_92:
+  vivify_95:
     find_lex $P219, "$/"
-    unless_null $P219, vivify_93
+    unless_null $P219, vivify_96
     new $P219, "Undef"
-  vivify_93:
+  vivify_96:
     $P220 = $P217."new"($P218 :named("name"), "call" :named("pasttype"), $P219 :named("node"))
     store_lex "$res", $P220
     find_lex $P222, "$/"
     set $P223, $P222["value"]
-    unless_null $P223, vivify_94
+    unless_null $P223, vivify_97
     new $P223, "Undef"
-  vivify_94:
+  vivify_97:
     defined $I224, $P223
-    unless $I224, for_undef_95
+    unless $I224, for_undef_98
     iter $P221, $P223
     new $P234, 'ExceptionHandler'
     set_addr $P234, loop233_handler
     eq $P235, 66, loop233_redo
   loop233_done:
     pop_eh 
-  for_undef_95:
+  for_undef_98:
     find_lex $P236, "$/"
     find_lex $P237, "$res"
-    unless_null $P237, vivify_98
+    unless_null $P237, vivify_101
     new $P237, "Undef"
-  vivify_98:
+  vivify_101:
     $P238 = $P236."result_object"($P237)
     .return ($P238)
   control_200:
     .param pmc param_228
     .lex "$_", param_228
     find_lex $P229, "$res"
-    unless_null $P229, vivify_96
+    unless_null $P229, vivify_99
     new $P229, "Undef"
-  vivify_96:
+  vivify_99:
     find_lex $P230, "$_"
-    unless_null $P230, vivify_97
+    unless_null $P230, vivify_100
     new $P230, "Undef"
-  vivify_97:
+  vivify_100:
     $P231 = $P230."item"()
     $P232 = $P229."push"($P231)
     .return ($P232)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "immediate"  :subid("26") :method :outer("42")
+.sub "immediate"  :subid("26") :method :outer("45")
     .param pmc param_243
     new $P242, 'ExceptionHandler'
     set_addr $P242, control_241
     .lex "$/", param_243
     find_lex $P244, "$/"
     set $P245, $P244["noun"]
-    unless_null $P245, vivify_99
+    unless_null $P245, vivify_102
     new $P245, "Undef"
-  vivify_99:
+  vivify_102:
     $P246 = $P245."item"()
     .lex "$value", $P246
     find_lex $P248, "$/"
     set $P249, $P248["adjective"]
-    unless_null $P249, vivify_100
+    unless_null $P249, vivify_103
     new $P249, "Undef"
-  vivify_100:
+  vivify_103:
     defined $I250, $P249
-    unless $I250, for_undef_101
+    unless $I250, for_undef_104
     iter $P247, $P249
     new $P269, 'ExceptionHandler'
     set_addr $P269, loop268_handler
     eq $P270, 66, loop268_redo
   loop268_done:
     pop_eh 
-  for_undef_101:
+  for_undef_104:
     find_lex $P271, "$/"
     get_hll_global $P272, ["PAST"], "Val"
     find_lex $P273, "$value"
-    unless_null $P273, vivify_107
+    unless_null $P273, vivify_110
     new $P273, "Undef"
-  vivify_107:
+  vivify_110:
     find_lex $P274, "$/"
-    unless_null $P274, vivify_108
+    unless_null $P274, vivify_111
     new $P274, "Undef"
-  vivify_108:
+  vivify_111:
     $P275 = $P272."new"($P273 :named("value"), "Integer" :named("returns"), $P274 :named("node"))
     $P276 = $P271."result_object"($P275)
     .return ($P276)
     .param pmc param_254
     .lex "$_", param_254
     find_lex $P259, "$_"
-    unless_null $P259, vivify_102
+    unless_null $P259, vivify_105
     new $P259, "Hash"
-  vivify_102:
+  vivify_105:
     set $P260, $P259["first_person_possessive"]
-    unless_null $P260, vivify_103
+    unless_null $P260, vivify_106
     new $P260, "Undef"
-  vivify_103:
+  vivify_106:
     unless $P260, unless_258
     set $P257, $P260
     goto unless_258_end
   unless_258:
     find_lex $P261, "$_"
-    unless_null $P261, vivify_104
+    unless_null $P261, vivify_107
     new $P261, "Hash"
-  vivify_104:
+  vivify_107:
     set $P262, $P261["second_person_possessive"]
-    unless_null $P262, vivify_105
+    unless_null $P262, vivify_108
     new $P262, "Undef"
-  vivify_105:
+  vivify_108:
     set $P257, $P262
   unless_258_end:
     unless $P257, unless_256
 .namespace ["z2";"Grammar";"Actions"]
 .sub "_block263"  :anon :subid("28") :outer("27")
     find_lex $P265, "$value"
-    unless_null $P265, vivify_106
+    unless_null $P265, vivify_109
     new $P265, "Undef"
-  vivify_106:
+  vivify_109:
     mul $P266, $P265, 2
     store_lex "$value", $P266
     .return ($P266)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "enters"  :subid("29") :method :outer("42")
+.sub "enters"  :subid("29") :method :outer("45")
     .param pmc param_281
     new $P280, 'ExceptionHandler'
     set_addr $P280, control_279
     .lex "$/", param_281
     get_hll_global $P282, ["PAST"], "Op"
     find_lex $P283, "$/"
-    unless_null $P283, vivify_109
+    unless_null $P283, vivify_112
     new $P283, "Undef"
-  vivify_109:
+  vivify_112:
     $P284 = $P282."new"("enter" :named("name"), "call" :named("pasttype"), $P283 :named("node"))
     .lex "$res", $P284
     find_lex $P286, "$/"
     set $P287, $P286["charlist"]
-    unless_null $P287, vivify_110
+    unless_null $P287, vivify_113
     new $P287, "Hash"
-  vivify_110:
+  vivify_113:
     set $P288, $P287["character"]
-    unless_null $P288, vivify_111
+    unless_null $P288, vivify_114
     new $P288, "Undef"
-  vivify_111:
+  vivify_114:
     defined $I289, $P288
-    unless $I289, for_undef_112
+    unless $I289, for_undef_115
     iter $P285, $P288
     new $P301, 'ExceptionHandler'
     set_addr $P301, loop300_handler
     eq $P302, 66, loop300_redo
   loop300_done:
     pop_eh 
-  for_undef_112:
+  for_undef_115:
     find_lex $P303, "$/"
     find_lex $P304, "$res"
-    unless_null $P304, vivify_116
+    unless_null $P304, vivify_119
     new $P304, "Undef"
-  vivify_116:
+  vivify_119:
     $P305 = $P303."result_object"($P304)
     .return ($P305)
   control_279:
     .param pmc param_293
     .lex "$_", param_293
     find_lex $P294, "$res"
-    unless_null $P294, vivify_113
+    unless_null $P294, vivify_116
     new $P294, "Undef"
-  vivify_113:
+  vivify_116:
     get_hll_global $P295, ["PAST"], "Val"
     find_lex $P296, "$_"
-    unless_null $P296, vivify_114
+    unless_null $P296, vivify_117
     new $P296, "Undef"
-  vivify_114:
+  vivify_117:
     find_lex $P297, "$_"
-    unless_null $P297, vivify_115
+    unless_null $P297, vivify_118
     new $P297, "Undef"
-  vivify_115:
+  vivify_118:
     $P298 = $P295."new"($P296 :named("value"), "String" :named("returns"), $P297 :named("node"))
     $P299 = $P294."push"($P298)
     .return ($P299)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "noun"  :subid("31") :method :outer("42")
+.sub "exits"  :subid("31") :method :outer("45")
     .param pmc param_310
-    .param pmc param_311
     new $P309, 'ExceptionHandler'
     set_addr $P309, control_308
     $P309."handle_types"(58)
     push_eh $P309
     .lex "$/", param_310
-    .lex "$k", param_311
-    find_lex $P314, "$k"
-    unless_null $P314, vivify_117
-    new $P314, "Undef"
-  vivify_117:
-    set $S315, $P314
-    iseq $I316, $S315, "one"
-    if $I316, if_313
-    find_lex $P324, "$k"
-    unless_null $P324, vivify_118
-    new $P324, "Undef"
-  vivify_118:
-    set $S325, $P324
-    iseq $I326, $S325, "minus_one"
-    if $I326, if_323
-    find_lex $P336, "$k"
-    unless_null $P336, vivify_119
-    new $P336, "Undef"
-  vivify_119:
-    set $S337, $P336
-    iseq $I338, $S337, "lookup"
-    if $I338, if_335
-    new $P334, 'Integer'
-    set $P334, $I338
-    goto if_335_end
-  if_335:
-    .const 'Sub' $P340 = "34" 
-    capture_lex $P340
-    $P342 = $P340()
-    set $P334, $P342
-  if_335_end:
-    set $P322, $P334
-    goto if_323_end
-  if_323:
-    .const 'Sub' $P328 = "33" 
-    capture_lex $P328
-    $P333 = $P328()
-    set $P322, $P333
-  if_323_end:
-    set $P312, $P322
-    goto if_313_end
-  if_313:
+    get_hll_global $P311, ["PAST"], "Op"
+    find_lex $P312, "$/"
+    unless_null $P312, vivify_120
+    new $P312, "Undef"
+  vivify_120:
+    $P313 = $P311."new"("exeunt" :named("name"), "call" :named("pasttype"), $P312 :named("node"))
+    .lex "$res", $P313
+    find_lex $P315, "$/"
+    set $P316, $P315["charlist"]
+    unless_null $P316, vivify_121
+    new $P316, "Undef"
+  vivify_121:
+    unless $P316, if_314_end
     .const 'Sub' $P318 = "32" 
     capture_lex $P318
-    $P321 = $P318()
-    set $P312, $P321
-  if_313_end:
-    .return ($P312)
+    $P318()
+  if_314_end:
+    find_lex $P337, "$/"
+    find_lex $P338, "$res"
+    unless_null $P338, vivify_128
+    new $P338, "Undef"
+  vivify_128:
+    $P339 = $P337."result_object"($P338)
+    .return ($P339)
   control_308:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P343, exception, "payload"
-    .return ($P343)
+    getattribute $P340, exception, "payload"
+    .return ($P340)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block339"  :anon :subid("34") :outer("31")
-    "say"("you")
-    $P341 = "panic"()
-    .return ($P341)
+.sub "_block317"  :anon :subid("32") :outer("31")
+    find_lex $P320, "$/"
+    set $P321, $P320["charlist"]
+    unless_null $P321, vivify_122
+    new $P321, "Hash"
+  vivify_122:
+    set $P322, $P321["character"]
+    unless_null $P322, vivify_123
+    new $P322, "Undef"
+  vivify_123:
+    defined $I323, $P322
+    unless $I323, for_undef_124
+    iter $P319, $P322
+    new $P335, 'ExceptionHandler'
+    set_addr $P335, loop334_handler
+    $P335."handle_types"(64, 66, 65)
+    push_eh $P335
+  loop334_test:
+    unless $P319, loop334_done
+    shift $P324, $P319
+  loop334_redo:
+    .const 'Sub' $P326 = "33" 
+    capture_lex $P326
+    $P326($P324)
+  loop334_next:
+    goto loop334_test
+  loop334_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P336, exception, 'type'
+    eq $P336, 64, loop334_next
+    eq $P336, 66, loop334_redo
+  loop334_done:
+    pop_eh 
+  for_undef_124:
+    .return ($P319)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block327"  :anon :subid("33") :outer("31")
-    find_lex $P329, "$/"
-    new $P330, "Integer"
-    assign $P330, 1
-    n_neg $P331, $P330
-    $P332 = $P329."result_object"($P331)
-    .return ($P332)
+.sub "_block325"  :anon :subid("33") :outer("32")
+    .param pmc param_327
+    .lex "$_", param_327
+    find_lex $P328, "$res"
+    unless_null $P328, vivify_125
+    new $P328, "Undef"
+  vivify_125:
+    get_hll_global $P329, ["PAST"], "Val"
+    find_lex $P330, "$_"
+    unless_null $P330, vivify_126
+    new $P330, "Undef"
+  vivify_126:
+    find_lex $P331, "$_"
+    unless_null $P331, vivify_127
+    new $P331, "Undef"
+  vivify_127:
+    $P332 = $P329."new"($P330 :named("value"), "String" :named("returns"), $P331 :named("node"))
+    $P333 = $P328."push"($P332)
+    .return ($P333)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block317"  :anon :subid("32") :outer("31")
-    find_lex $P319, "$/"
-    $P320 = $P319."result_object"(1)
-    .return ($P320)
-.end
-
-
-.namespace ["z2";"Grammar";"Actions"]
-.sub "tap"  :subid("35") :method :outer("42")
-    .param pmc param_347
-    new $P346, 'ExceptionHandler'
-    set_addr $P346, control_345
-    $P346."handle_types"(58)
-    push_eh $P346
-    .lex "$/", param_347
-    get_hll_global $P348, ["PAST"], "Op"
-    find_lex $P349, "$/"
-    unless_null $P349, vivify_120
-    new $P349, "Undef"
-  vivify_120:
-    $P350 = $P348."new"("tap" :named("name"), "call" :named("pasttype"), $P349 :named("node"))
-    .lex "$res", $P350
-    find_lex $P351, "$res"
-    unless_null $P351, vivify_121
-    new $P351, "Undef"
-  vivify_121:
-    find_lex $P352, "$/"
-    set $P353, $P352["value"]
-    unless_null $P353, vivify_122
-    new $P353, "Undef"
-  vivify_122:
-    $P354 = $P353."item"()
-    $P351."push"($P354)
-    find_lex $P355, "$/"
-    find_lex $P356, "$res"
-    unless_null $P356, vivify_123
-    new $P356, "Undef"
-  vivify_123:
-    $P357 = $P355."result_object"($P356)
-    .return ($P357)
-  control_345:
+.sub "noun"  :subid("34") :method :outer("45")
+    .param pmc param_344
+    .param pmc param_345
+    new $P343, 'ExceptionHandler'
+    set_addr $P343, control_342
+    $P343."handle_types"(58)
+    push_eh $P343
+    .lex "$/", param_344
+    .lex "$k", param_345
+    find_lex $P348, "$k"
+    unless_null $P348, vivify_129
+    new $P348, "Undef"
+  vivify_129:
+    set $S349, $P348
+    iseq $I350, $S349, "one"
+    if $I350, if_347
+    find_lex $P358, "$k"
+    unless_null $P358, vivify_130
+    new $P358, "Undef"
+  vivify_130:
+    set $S359, $P358
+    iseq $I360, $S359, "minus_one"
+    if $I360, if_357
+    find_lex $P370, "$k"
+    unless_null $P370, vivify_131
+    new $P370, "Undef"
+  vivify_131:
+    set $S371, $P370
+    iseq $I372, $S371, "lookup"
+    if $I372, if_369
+    new $P368, 'Integer'
+    set $P368, $I372
+    goto if_369_end
+  if_369:
+    .const 'Sub' $P374 = "37" 
+    capture_lex $P374
+    $P376 = $P374()
+    set $P368, $P376
+  if_369_end:
+    set $P356, $P368
+    goto if_357_end
+  if_357:
+    .const 'Sub' $P362 = "36" 
+    capture_lex $P362
+    $P367 = $P362()
+    set $P356, $P367
+  if_357_end:
+    set $P346, $P356
+    goto if_347_end
+  if_347:
+    .const 'Sub' $P352 = "35" 
+    capture_lex $P352
+    $P355 = $P352()
+    set $P346, $P355
+  if_347_end:
+    .return ($P346)
+  control_342:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P358, exception, "payload"
-    .return ($P358)
+    getattribute $P377, exception, "payload"
+    .return ($P377)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "plan"  :subid("36") :method :outer("42")
-    .param pmc param_362
-    new $P361, 'ExceptionHandler'
-    set_addr $P361, control_360
-    $P361."handle_types"(58)
-    push_eh $P361
-    .lex "$/", param_362
-    get_hll_global $P363, ["PAST"], "Op"
-    find_lex $P364, "$/"
-    unless_null $P364, vivify_124
-    new $P364, "Undef"
-  vivify_124:
-    $P365 = $P363."new"("plan" :named("name"), "call" :named("pasttype"), $P364 :named("node"))
-    .lex "$res", $P365
-    find_lex $P366, "$res"
-    unless_null $P366, vivify_125
-    new $P366, "Undef"
-  vivify_125:
-    find_lex $P367, "$/"
-    set $P368, $P367["value"]
-    unless_null $P368, vivify_126
-    new $P368, "Undef"
-  vivify_126:
-    $P369 = $P368."item"()
-    $P366."push"($P369)
-    find_lex $P370, "$/"
-    find_lex $P371, "$res"
-    unless_null $P371, vivify_127
-    new $P371, "Undef"
-  vivify_127:
-    $P372 = $P370."result_object"($P371)
-    .return ($P372)
-  control_360:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P373, exception, "payload"
-    .return ($P373)
-    rethrow exception
+.sub "_block373"  :anon :subid("37") :outer("34")
+    "say"("you")
+    $P375 = "panic"()
+    .return ($P375)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "test"  :subid("37") :method :outer("42")
-    .param pmc param_377
-    .param pmc param_378
-    new $P376, 'ExceptionHandler'
-    set_addr $P376, control_375
-    $P376."handle_types"(58)
-    push_eh $P376
-    .lex "$/", param_377
-    .lex "$k", param_378
-    get_hll_global $P379, ["PAST"], "Var"
-    find_lex $P380, "$/"
-    unless_null $P380, vivify_128
-    new $P380, "Undef"
-  vivify_128:
-    $P381 = $P379."new"("the_condition" :named("name"), 0 :named("isdecl"), "package" :named("scope"), $P380 :named("node"))
-    .lex "$test", $P381
-    find_lex $P382, "$/"
-    get_hll_global $P383, ["PAST"], "Op"
-    find_lex $P384, "$test"
-    unless_null $P384, vivify_129
-    new $P384, "Undef"
-  vivify_129:
-    find_lex $P385, "$/"
-    set $P386, $P385["branch"]
-    unless_null $P386, vivify_130
-    new $P386, "Undef"
-  vivify_130:
-    $P387 = $P386."item"()
-    find_lex $P388, "$k"
-    unless_null $P388, vivify_131
-    new $P388, "Undef"
-  vivify_131:
+.sub "_block361"  :anon :subid("36") :outer("34")
+    find_lex $P363, "$/"
+    new $P364, "Integer"
+    assign $P364, 1
+    n_neg $P365, $P364
+    $P366 = $P363."result_object"($P365)
+    .return ($P366)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "_block351"  :anon :subid("35") :outer("34")
+    find_lex $P353, "$/"
+    $P354 = $P353."result_object"(1)
+    .return ($P354)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "tap"  :subid("38") :method :outer("45")
+    .param pmc param_381
+    new $P380, 'ExceptionHandler'
+    set_addr $P380, control_379
+    $P380."handle_types"(58)
+    push_eh $P380
+    .lex "$/", param_381
+    get_hll_global $P382, ["PAST"], "Op"
+    find_lex $P383, "$/"
+    unless_null $P383, vivify_132
+    new $P383, "Undef"
+  vivify_132:
+    $P384 = $P382."new"("tap" :named("name"), "call" :named("pasttype"), $P383 :named("node"))
+    .lex "$res", $P384
+    find_lex $P385, "$res"
+    unless_null $P385, vivify_133
+    new $P385, "Undef"
+  vivify_133:
+    find_lex $P386, "$/"
+    set $P387, $P386["value"]
+    unless_null $P387, vivify_134
+    new $P387, "Undef"
+  vivify_134:
+    $P388 = $P387."item"()
+    $P385."push"($P388)
     find_lex $P389, "$/"
-    unless_null $P389, vivify_132
-    new $P389, "Undef"
-  vivify_132:
-    $P390 = $P383."new"($P384, $P387, $P388 :named("pasttype"), $P389 :named("node"))
-    $P391 = $P382."result_object"($P390)
+    find_lex $P390, "$res"
+    unless_null $P390, vivify_135
+    new $P390, "Undef"
+  vivify_135:
+    $P391 = $P389."result_object"($P390)
     .return ($P391)
-  control_375:
+  control_379:
     .local pmc exception 
     .get_results (exception) 
     getattribute $P392, exception, "payload"
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "computation"  :subid("38") :method :outer("42")
+.sub "plan"  :subid("39") :method :outer("45")
     .param pmc param_396
-    .param pmc param_397
     new $P395, 'ExceptionHandler'
     set_addr $P395, control_394
     $P395."handle_types"(58)
     push_eh $P395
     .lex "$/", param_396
-    .lex "$key", param_397
+    get_hll_global $P397, ["PAST"], "Op"
     find_lex $P398, "$/"
-    find_lex $P399, "$key"
-    unless_null $P399, vivify_133
-    new $P399, "Undef"
-  vivify_133:
-    find_lex $P400, "$/"
-    unless_null $P400, vivify_134
-    new $P400, "Hash"
-  vivify_134:
-    set $P401, $P400[$P399]
-    unless_null $P401, vivify_135
-    new $P401, "Undef"
-  vivify_135:
-    $P402 = $P401."item"()
-    $P403 = $P398."result_object"($P402)
-    .return ($P403)
+    unless_null $P398, vivify_136
+    new $P398, "Undef"
+  vivify_136:
+    $P399 = $P397."new"("plan" :named("name"), "call" :named("pasttype"), $P398 :named("node"))
+    .lex "$res", $P399
+    find_lex $P400, "$res"
+    unless_null $P400, vivify_137
+    new $P400, "Undef"
+  vivify_137:
+    find_lex $P401, "$/"
+    set $P402, $P401["value"]
+    unless_null $P402, vivify_138
+    new $P402, "Undef"
+  vivify_138:
+    $P403 = $P402."item"()
+    $P400."push"($P403)
+    find_lex $P404, "$/"
+    find_lex $P405, "$res"
+    unless_null $P405, vivify_139
+    new $P405, "Undef"
+  vivify_139:
+    $P406 = $P404."result_object"($P405)
+    .return ($P406)
   control_394:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P404, exception, "payload"
-    .return ($P404)
+    getattribute $P407, exception, "payload"
+    .return ($P407)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "unary"  :subid("39") :method :outer("42")
-    .param pmc param_408
-    .param pmc param_409
-    new $P407, 'ExceptionHandler'
-    set_addr $P407, control_406
-    $P407."handle_types"(58)
-    push_eh $P407
-    .lex "$/", param_408
-    .lex "$key", param_409
-    get_hll_global $P410, ["PAST"], "Op"
-    find_lex $P411, "$key"
-    unless_null $P411, vivify_136
-    new $P411, "Undef"
-  vivify_136:
-    find_lex $P412, "$/"
-    unless_null $P412, vivify_137
-    new $P412, "Undef"
-  vivify_137:
-    $P413 = $P410."new"($P411 :named("name"), "call" :named("pasttype"), $P412 :named("node"))
-    .lex "$res", $P413
-    find_lex $P414, "$res"
-    unless_null $P414, vivify_138
+.sub "test"  :subid("40") :method :outer("45")
+    .param pmc param_411
+    .param pmc param_412
+    new $P410, 'ExceptionHandler'
+    set_addr $P410, control_409
+    $P410."handle_types"(58)
+    push_eh $P410
+    .lex "$/", param_411
+    .lex "$k", param_412
+    get_hll_global $P413, ["PAST"], "Var"
+    find_lex $P414, "$/"
+    unless_null $P414, vivify_140
     new $P414, "Undef"
-  vivify_138:
-    find_lex $P415, "$/"
-    set $P416, $P415["value"]
-    unless_null $P416, vivify_139
-    new $P416, "Undef"
-  vivify_139:
-    $P417 = $P416."item"()
-    $P414."push"($P417)
-    find_lex $P418, "$/"
-    find_lex $P419, "$res"
-    unless_null $P419, vivify_140
-    new $P419, "Undef"
   vivify_140:
-    $P420 = $P418."result_object"($P419)
-    .return ($P420)
-  control_406:
+    $P415 = $P413."new"("the_condition" :named("name"), 0 :named("isdecl"), "package" :named("scope"), $P414 :named("node"))
+    .lex "$test", $P415
+    find_lex $P416, "$/"
+    get_hll_global $P417, ["PAST"], "Op"
+    find_lex $P418, "$test"
+    unless_null $P418, vivify_141
+    new $P418, "Undef"
+  vivify_141:
+    find_lex $P419, "$/"
+    set $P420, $P419["branch"]
+    unless_null $P420, vivify_142
+    new $P420, "Undef"
+  vivify_142:
+    $P421 = $P420."item"()
+    find_lex $P422, "$k"
+    unless_null $P422, vivify_143
+    new $P422, "Undef"
+  vivify_143:
+    find_lex $P423, "$/"
+    unless_null $P423, vivify_144
+    new $P423, "Undef"
+  vivify_144:
+    $P424 = $P417."new"($P418, $P421, $P422 :named("pasttype"), $P423 :named("node"))
+    $P425 = $P416."result_object"($P424)
+    .return ($P425)
+  control_409:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P421, exception, "payload"
-    .return ($P421)
+    getattribute $P426, exception, "payload"
+    .return ($P426)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "binary"  :subid("40") :method :outer("42")
-    .param pmc param_425
-    .param pmc param_426
-    new $P424, 'ExceptionHandler'
-    set_addr $P424, control_423
-    $P424."handle_types"(58)
-    push_eh $P424
-    .lex "$/", param_425
-    .lex "$key", param_426
-    get_hll_global $P427, ["PAST"], "Op"
-    find_lex $P428, "$key"
-    unless_null $P428, vivify_141
-    new $P428, "Undef"
-  vivify_141:
-    find_lex $P429, "$/"
-    unless_null $P429, vivify_142
-    new $P429, "Undef"
-  vivify_142:
-    $P430 = $P427."new"($P428 :named("name"), "call" :named("pasttype"), $P429 :named("node"))
-    .lex "$res", $P430
+.sub "computation"  :subid("41") :method :outer("45")
+    .param pmc param_430
+    .param pmc param_431
+    new $P429, 'ExceptionHandler'
+    set_addr $P429, control_428
+    $P429."handle_types"(58)
+    push_eh $P429
+    .lex "$/", param_430
+    .lex "$key", param_431
     find_lex $P432, "$/"
-    set $P433, $P432["value"]
-    unless_null $P433, vivify_143
+    find_lex $P433, "$key"
+    unless_null $P433, vivify_145
     new $P433, "Undef"
-  vivify_143:
-    defined $I434, $P433
-    unless $I434, for_undef_144
-    iter $P431, $P433
-    new $P444, 'ExceptionHandler'
-    set_addr $P444, loop443_handler
-    $P444."handle_types"(64, 66, 65)
-    push_eh $P444
-  loop443_test:
-    unless $P431, loop443_done
-    shift $P435, $P431
-  loop443_redo:
-    .const 'Sub' $P437 = "41" 
-    capture_lex $P437
-    $P437($P435)
-  loop443_next:
-    goto loop443_test
-  loop443_handler:
+  vivify_145:
+    find_lex $P434, "$/"
+    unless_null $P434, vivify_146
+    new $P434, "Hash"
+  vivify_146:
+    set $P435, $P434[$P433]
+    unless_null $P435, vivify_147
+    new $P435, "Undef"
+  vivify_147:
+    $P436 = $P435."item"()
+    $P437 = $P432."result_object"($P436)
+    .return ($P437)
+  control_428:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P445, exception, 'type'
-    eq $P445, 64, loop443_next
-    eq $P445, 66, loop443_redo
-  loop443_done:
-    pop_eh 
-  for_undef_144:
-    find_lex $P446, "$/"
-    find_lex $P447, "$res"
-    unless_null $P447, vivify_147
-    new $P447, "Undef"
-  vivify_147:
-    $P448 = $P446."result_object"($P447)
-    .return ($P448)
-  control_423:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P449, exception, "payload"
-    .return ($P449)
+    getattribute $P438, exception, "payload"
+    .return ($P438)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block436"  :anon :subid("41") :outer("40")
-    .param pmc param_438
-    .lex "$_", param_438
-    find_lex $P439, "$res"
-    unless_null $P439, vivify_145
-    new $P439, "Undef"
-  vivify_145:
-    find_lex $P440, "$_"
-    unless_null $P440, vivify_146
-    new $P440, "Undef"
-  vivify_146:
-    $P441 = $P440."item"()
-    $P442 = $P439."push"($P441)
-    .return ($P442)
+.sub "unary"  :subid("42") :method :outer("45")
+    .param pmc param_442
+    .param pmc param_443
+    new $P441, 'ExceptionHandler'
+    set_addr $P441, control_440
+    $P441."handle_types"(58)
+    push_eh $P441
+    .lex "$/", param_442
+    .lex "$key", param_443
+    get_hll_global $P444, ["PAST"], "Op"
+    find_lex $P445, "$key"
+    unless_null $P445, vivify_148
+    new $P445, "Undef"
+  vivify_148:
+    find_lex $P446, "$/"
+    unless_null $P446, vivify_149
+    new $P446, "Undef"
+  vivify_149:
+    $P447 = $P444."new"($P445 :named("name"), "call" :named("pasttype"), $P446 :named("node"))
+    .lex "$res", $P447
+    find_lex $P448, "$res"
+    unless_null $P448, vivify_150
+    new $P448, "Undef"
+  vivify_150:
+    find_lex $P449, "$/"
+    set $P450, $P449["value"]
+    unless_null $P450, vivify_151
+    new $P450, "Undef"
+  vivify_151:
+    $P451 = $P450."item"()
+    $P448."push"($P451)
+    find_lex $P452, "$/"
+    find_lex $P453, "$res"
+    unless_null $P453, vivify_152
+    new $P453, "Undef"
+  vivify_152:
+    $P454 = $P452."result_object"($P453)
+    .return ($P454)
+  control_440:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P455, exception, "payload"
+    .return ($P455)
+    rethrow exception
 .end
 
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "binary"  :subid("43") :method :outer("45")
+    .param pmc param_459
+    .param pmc param_460
+    new $P458, 'ExceptionHandler'
+    set_addr $P458, control_457
+    $P458."handle_types"(58)
+    push_eh $P458
+    .lex "$/", param_459
+    .lex "$key", param_460
+    get_hll_global $P461, ["PAST"], "Op"
+    find_lex $P462, "$key"
+    unless_null $P462, vivify_153
+    new $P462, "Undef"
+  vivify_153:
+    find_lex $P463, "$/"
+    unless_null $P463, vivify_154
+    new $P463, "Undef"
+  vivify_154:
+    $P464 = $P461."new"($P462 :named("name"), "call" :named("pasttype"), $P463 :named("node"))
+    .lex "$res", $P464
+    find_lex $P466, "$/"
+    set $P467, $P466["value"]
+    unless_null $P467, vivify_155
+    new $P467, "Undef"
+  vivify_155:
+    defined $I468, $P467
+    unless $I468, for_undef_156
+    iter $P465, $P467
+    new $P478, 'ExceptionHandler'
+    set_addr $P478, loop477_handler
+    $P478."handle_types"(64, 66, 65)
+    push_eh $P478
+  loop477_test:
+    unless $P465, loop477_done
+    shift $P469, $P465
+  loop477_redo:
+    .const 'Sub' $P471 = "44" 
+    capture_lex $P471
+    $P471($P469)
+  loop477_next:
+    goto loop477_test
+  loop477_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P479, exception, 'type'
+    eq $P479, 64, loop477_next
+    eq $P479, 66, loop477_redo
+  loop477_done:
+    pop_eh 
+  for_undef_156:
+    find_lex $P480, "$/"
+    find_lex $P481, "$res"
+    unless_null $P481, vivify_159
+    new $P481, "Undef"
+  vivify_159:
+    $P482 = $P480."result_object"($P481)
+    .return ($P482)
+  control_457:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P483, exception, "payload"
+    .return ($P483)
+    rethrow exception
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "_block470"  :anon :subid("44") :outer("43")
+    .param pmc param_472
+    .lex "$_", param_472
+    find_lex $P473, "$res"
+    unless_null $P473, vivify_157
+    new $P473, "Undef"
+  vivify_157:
+    find_lex $P474, "$_"
+    unless_null $P474, vivify_158
+    new $P474, "Undef"
+  vivify_158:
+    $P475 = $P474."item"()
+    $P476 = $P473."push"($P475)
+    .return ($P476)
+.end
+

src/gen_builtins.pir

     print "enter\n"
     .return ()
 .end
+.sub 'exeunt'
+    .param pmc args :slurpy
+    print "exeunt\n"
+    .return ()
+.end
 .sub 'say2'
     print "hello\n"
     .return ()

src/gen_grammar.pir

       .sub '__onload' :load :init
           .local pmc optable
           ## namespace z2::Grammar
-          push_eh onload_1428
+          push_eh onload_1426
           .local pmc p6meta
           p6meta = get_hll_global 'P6metaclass'
           p6meta.'new_class'('z2::Grammar', 'parent'=>'PCT::Grammar')
-        onload_1428:
+        onload_1426:
           pop_eh
           .return ()
       .end
           if cpos > lastpos goto fail_rule
           .local pmc cstack :unique_reg
           cstack = new 'ResizableIntegerArray'
-          .local pmc ustack :unique_reg
-          ustack = new 'ResizablePMCArray'
-          .local pmc gpad :unique_reg
-          gpad = new 'ResizablePMCArray'
           .local pmc captscope, captob :unique_reg
           captscope = mob
           .local int pos, rep, cutmark :unique_reg
           local_branch cstack, R742
           
           goto fail
-        R742:  # quant 0..1 (3) greedy/none
-          push gpad, 0
-          local_branch cstack, R742_repeat
-          $I0 = pop gpad
-          if cutmark != 745 goto fail
-          cutmark = 0
-          goto fail
-        R742_repeat:
-          rep = gpad[-1]
-          if rep >= 1 goto R742_1
-          inc rep
-          gpad[-1] = rep
-          push ustack, pos
-          push ustack, rep
-          local_branch cstack, R744
-          rep = pop ustack
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          dec rep
+        R742: # subrule charlist
+          captob = captscope
+          $P0 = getattribute captob, '$.pos'
+          $P0 = pos
+          $I0 = can mob, 'charlist'
+          if $I0 == 0 goto R742_1
+          $P0 = find_method mob, 'charlist'
+          goto R742_2
         R742_1:
-          ### if rep < 0 goto fail
-          $I0 = pop gpad
-          push ustack, rep
+          $P0 = find_name 'charlist'
+          unless null $P0 goto R742_2
+          say "Unable to find regex 'charlist'"
+        R742_2:
+          $P2 = adverbs['action']
+          captob = $P0(captob, 'action'=>$P2)
+          $P1 = getattribute captob, '$.pos'
+          if $P1 <= -3 goto fail_match
+          if $P1 < 0 goto fail
+          
+          captscope["charlist"] = captob
+
+          pos = $P1
           local_branch cstack, R743
-          rep = pop ustack
-          push gpad, rep
-          if cutmark != 0 goto fail
-          cutmark = 745
-          goto fail
-
-        R744: # subrule charlist
-          captob = captscope
-          $P0 = getattribute captob, '$.pos'
-          $P0 = pos
-          $I0 = can mob, 'charlist'
-          if $I0 == 0 goto R744_1
-          $P0 = find_method mob, 'charlist'
-          goto R744_2
-        R744_1:
-          $P0 = find_name 'charlist'
-          unless null $P0 goto R744_2
-          say "Unable to find regex 'charlist'"
-        R744_2:
-          $P2 = adverbs['action']
-          captob = $P0(captob, 'action'=>$P2)
-          $P1 = getattribute captob, '$.pos'
-          if $P1 <= -3 goto fail_match
-          if $P1 < 0 goto fail
-                    $I0 = defined captscope["charlist"]
-          if $I0 goto R744_cgen
-          $P0 = new 'ResizablePMCArray'
-          captscope["charlist"] = $P0
-          local_branch cstack, R744_cgen
           delete captscope["charlist"]
-          goto fail
-        R744_cgen:
-
-          $P2 = captscope["charlist"]
-          push $P2, captob
-
-          pos = $P1
-          local_branch cstack, R742_repeat
-          $P2 = captscope["charlist"]
-          $P2 = pop $P2
 
           goto fail
         R743: # subrule ws
           
           
           pos = $P1
+          local_branch cstack, R744
+          
+          goto fail
+        R744: # action
+          $P1 = adverbs['action']
+          if null $P1 goto R745
+          $I1 = can $P1, "exits"
+          if $I1 == 0 goto R745
+          mpos = pos
+          $P1."exits"(mob)
+          goto R745
+        R745: # subrule ws
+          captob = captscope
+          $P0 = getattribute captob, '$.pos'
+          $P0 = pos
+          $I0 = can mob, 'ws'
+          if $I0 == 0 goto R745_1
+          $P0 = find_method mob, 'ws'
+          goto R745_2
+        R745_1:
+          $P0 = find_name 'ws'
+          unless null $P0 goto R745_2
+          say "Unable to find regex 'ws'"
+        R745_2:
+          $P2 = adverbs['action']
+          captob = $P0(captob, 'action'=>$P2)
+          $P1 = getattribute captob, '$.pos'
+          if $P1 <= -3 goto fail_match
+          if $P1 < 0 goto fail
+          
+          
+          pos = $P1
           local_branch cstack, R746
           
           goto fail
-        R746: # action
-          $P1 = adverbs['action']
-          if null $P1 goto R747
-          $I1 = can $P1, "exits"
-          if $I1 == 0 goto R747
-          mpos = pos
-          $P1."exits"(mob)
+        R746: # literal
+          $I0 = pos + 1
+          if $I0 > lastpos goto fail
+          $S0 = substr target, pos, 1
+          
+          if $S0 != "]" goto fail
+          pos += 1
           goto R747
+
         R747: # subrule ws
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           
           
           pos = $P1
-          local_branch cstack, R748
-          
-          goto fail
-        R748: # literal
-          $I0 = pos + 1
-          if $I0 > lastpos goto fail
-          $S0 = substr target, pos, 1
-          
-          if $S0 != "]" goto fail
-          pos += 1
-          goto R749
-
-        R749: # subrule ws
-          captob = captscope
-          $P0 = getattribute captob, '$.pos'
-          $P0 = pos
-          $I0 = can mob, 'ws'
-          if $I0 == 0 goto R749_1
-          $P0 = find_method mob, 'ws'
-          goto R749_2
-        R749_1:
-          $P0 = find_name 'ws'
-          unless null $P0 goto R749_2
-          say "Unable to find regex 'ws'"
-        R749_2:
-          $P2 = adverbs['action']
-          captob = $P0(captob, 'action'=>$P2)
-          $P1 = getattribute captob, '$.pos'
-          if $P1 <= -3 goto fail_match
-          if $P1 < 0 goto fail
-          
-          
-          pos = $P1
           local_branch cstack, succeed
           
           goto fail
           local_return cstack
         R:  # quant 0..Inf none
           local_branch cstack, R_repeat
-          if cutmark != 751 goto fail
+          if cutmark != 749 goto fail
           cutmark = 0
           goto fail
         R_repeat:
           push ustack, pos
-          local_branch cstack, R750
+          local_branch cstack, R748
           pos = pop ustack
           if cutmark != 0 goto fail
           local_branch cstack, succeed
           if cutmark != 0 goto fail
-          cutmark = 751
-          goto fail
-        R750: # concat
-        R752: # enumcharlist "."
+          cutmark = 749
+          goto fail
+        R748: # concat
+        R750: # enumcharlist "."
           if pos >= lastpos goto fail
           $S0 = substr target, pos, 1
           $I0 = index ".", $S0
           if $I0 >= 0 goto fail
           ###   zero width
-          goto R753
-        R753: # cclass .
+          goto R751
+        R751: # cclass .
           if pos >= lastpos goto fail
           inc pos
           goto R_repeat
           .return (mob)
         fail:
           local_return cstack
-        R:  # alt R754, R755
+        R:  # alt R752, R753
+          push ustack, pos
+          local_branch cstack, R752
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R753
+
+        R752:  # alt R754, R755
           push ustack, pos
           local_branch cstack, R754
           pos = pop ustack
           if cutmark != 0 goto fail
           goto R755
 
-        R754:  # alt R756, R757
-          push ustack, pos
-          local_branch cstack, R756
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R757
-
-        R756: # literal
+        R754: # literal
           $I0 = pos + 1
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 1
           pos += 1
           goto succeed
 
-        R757: # literal
+        R755: # literal
           $I0 = pos + 2
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 2
           pos += 2
           goto succeed
 
-        R755: # literal
+        R753: # literal
           $I0 = pos + 3
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 3
           .return (mob)
         fail:
           local_return cstack
-        R:  # alt R758, R759
+        R:  # alt R756, R757
+          push ustack, pos
+          local_branch cstack, R756
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R757
+
+        R756:  # alt R758, R759
           push ustack, pos
           local_branch cstack, R758
           pos = pop ustack
           if cutmark != 0 goto fail
           goto R763
 
-        R762:  # alt R764, R765
-          push ustack, pos
-          local_branch cstack, R764
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R765
-
-        R764: # literal
+        R762: # literal
           $I0 = pos + 2
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 2
           pos += 2
           goto succeed
 
-        R765: # literal
+        R763: # literal
           $I0 = pos + 3
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 3
           pos += 3
           goto succeed
 
-        R763: # literal
+        R761: # literal
           $I0 = pos + 3
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 3
           pos += 3
           goto succeed
 
-        R761: # literal
+        R759: # literal
           $I0 = pos + 2
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 2
           pos += 2
           goto succeed
 
-        R759: # literal
+        R757: # literal
           $I0 = pos + 2
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 2
           .return (mob)
         fail:
           local_return cstack
-        R:  # alt R766, R767
+        R:  # alt R764, R765
+          push ustack, pos
+          local_branch cstack, R764
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R765
+
+        R764:  # alt R766, R767
           push ustack, pos
           local_branch cstack, R766
           pos = pop ustack
           if cutmark != 0 goto fail
           goto R1065
 
-        R1064:  # alt R1066, R1067
-          push ustack, pos
-          local_branch cstack, R1066
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R1067
-
-        R1066: # literal
+        R1064: # literal
           $I0 = pos + 8
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 8
           pos += 8
           goto succeed
 
-        R1067: # literal
+        R1065: # literal
           $I0 = pos + 6
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 6
           pos += 6
           goto succeed
 
-        R1065: # literal
+        R1063: # literal
           $I0 = pos + 7
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 7
           pos += 7
           goto succeed
 
-        R1063: # literal
+        R1061: # literal
           $I0 = pos + 6
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 6
           pos += 6
           goto succeed
 
-        R1061: # literal
+        R1059: # literal
           $I0 = pos + 7
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 7
           pos += 7
           goto succeed
 
-        R1059: # literal
+        R1057: # literal
           $I0 = pos + 9
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 9
           pos += 9
           goto succeed
 
-        R1057: # literal
+        R1055: # literal
           $I0 = pos + 7
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 7
           pos += 7
           goto succeed
 
-        R1055: # literal
+        R1053: # literal
           $I0 = pos + 4
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 4
           pos += 4
           goto succeed
 
-        R1053: # literal
+        R1051: # literal
           $I0 = pos + 6
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 6
           pos += 6
           goto succeed
 
-        R1051: # literal
+        R1049: # literal
           $I0 = pos + 10
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 10
           pos += 10
           goto succeed
 
-        R1049: # literal
+        R1047: # literal
           $I0 = pos + 6
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 6
           pos += 6
           goto succeed
 
-        R1047: # literal
+        R1045: # literal
           $I0 = pos + 9
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 9
           pos += 9
           goto succeed
 
-        R1045: # literal
+        R1043: # literal
           $I0 = pos + 7
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 7
           pos += 7
           goto succeed
 
-        R1043: # literal
+        R1041: # literal
           $I0 = pos + 6
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 6
           pos += 6
           goto succeed
 
-        R1041: # literal
+        R1039: # literal
           $I0 = pos + 9
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 9
           pos += 9
           goto succeed
 
-        R1039: # literal
+        R1037: # literal
           $I0 = pos + 9
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 9
           pos += 9
           goto succeed
 
-        R1037: # literal
+        R1035: # literal
           $I0 = pos + 6
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 6
           pos += 6
           goto succeed
 
-        R1035: # literal
+        R1033: # literal
           $I0 = pos + 8
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 8
           pos += 8
           goto succeed
 
-        R1033: # literal
+        R1031: # literal
           $I0 = pos + 8
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 8
           pos += 8
           goto succeed
 
-        R1031: # literal
+        R1029: # literal
           $I0 = pos + 8
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 8
           pos += 8
           goto succeed
 
-        R1029: # literal
+        R1027: # literal
           $I0 = pos + 6
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 6
           pos += 6
           goto succeed
 
-        R1027: # literal
+        R1025: # literal
           $I0 = pos + 9
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 9
           pos += 9
           goto succeed
 
-        R1025: # literal
+        R1023: # literal
           $I0 = pos + 6
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 6
           pos += 6
           goto succeed
 
-        R1023: # literal
+        R1021: # literal
           $I0 = pos + 7
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 7
           pos += 7
           goto succeed
 
-        R1021: # literal
+        R1019: # literal
           $I0 = pos + 9
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 9