Commits

Anonymous committed 339ba6b

dbg()

  • Participants
  • Parent commits 28cde2a

Comments (0)

Files changed (3)

File src/gen_actions.pir

 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block13" :init :load :subid("30")
-    .const 'Sub' $P260 = "28" 
-    capture_lex $P260
-    .const 'Sub' $P243 = "27" 
-    capture_lex $P243
-    .const 'Sub' $P231 = "26" 
-    capture_lex $P231
-    .const 'Sub' $P219 = "25" 
-    capture_lex $P219
-    .const 'Sub' $P194 = "23" 
-    capture_lex $P194
-    .const 'Sub' $P166 = "21" 
-    capture_lex $P166
+.sub "_block13" :init :load :subid("32")
+    .const 'Sub' $P273 = "30" 
+    capture_lex $P273
+    .const 'Sub' $P256 = "29" 
+    capture_lex $P256
+    .const 'Sub' $P244 = "28" 
+    capture_lex $P244
+    .const 'Sub' $P232 = "27" 
+    capture_lex $P232
+    .const 'Sub' $P207 = "25" 
+    capture_lex $P207
+    .const 'Sub' $P179 = "23" 
+    capture_lex $P179
+    .const 'Sub' $P167 = "22" 
+    capture_lex $P167
     .const 'Sub' $P154 = "20" 
     capture_lex $P154
     .const 'Sub' $P139 = "19" 
         $P2 = $P0.'new_class'($P1)
       subclass_done:
         pop_eh
-    .const 'Sub' $P260 = "28" 
-    capture_lex $P260
-    .return ($P260)
+    .const 'Sub' $P273 = "30" 
+    capture_lex $P273
+    .return ($P273)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "TOP"  :subid("11") :method :outer("30")
+.sub "TOP"  :subid("11") :method :outer("32")
     .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_31
+    unless_null $P20, vivify_33
     new $P20, "Undef"
-  vivify_31:
+  vivify_33:
     $P21 = $P19."new"($P20 :named("node"))
     .lex "$past", $P21
     find_lex $P23, "$/"
     set $P24, $P23["scene"]
-    unless_null $P24, vivify_32
+    unless_null $P24, vivify_34
     new $P24, "Undef"
-  vivify_32:
+  vivify_34:
     defined $I25, $P24
-    unless $I25, for_undef_33
+    unless $I25, for_undef_35
     iter $P22, $P24
     new $P35, 'ExceptionHandler'
     set_addr $P35, loop34_handler
     eq $P36, 66, loop34_redo
   loop34_done:
     pop_eh 
-  for_undef_33:
+  for_undef_35:
     find_lex $P37, "$/"
     find_lex $P38, "$past"
-    unless_null $P38, vivify_36
+    unless_null $P38, vivify_38
     new $P38, "Undef"
-  vivify_36:
+  vivify_38:
     $P39 = $P37."result_object"($P38)
     .return ($P39)
   control_16:
     .param pmc param_29
     .lex "$_", param_29
     find_lex $P30, "$past"
-    unless_null $P30, vivify_34
+    unless_null $P30, vivify_36
     new $P30, "Undef"
-  vivify_34:
+  vivify_36:
     find_lex $P31, "$_"
-    unless_null $P31, vivify_35
+    unless_null $P31, vivify_37
     new $P31, "Undef"
-  vivify_35:
+  vivify_37:
     $P32 = $P31."item"()
     $P33 = $P30."push"($P32)
     .return ($P33)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "scene"  :subid("13") :method :outer("30")
+.sub "scene"  :subid("13") :method :outer("32")
     .param pmc param_44
     new $P43, 'ExceptionHandler'
     set_addr $P43, control_42
     get_hll_global $P45, ["PAST"], "Stmts"
     find_lex $P46, "$/"
     set $P47, $P46["roman"]
-    unless_null $P47, vivify_37
+    unless_null $P47, vivify_39
     new $P47, "Undef"
-  vivify_37:
+  vivify_39:
     find_lex $P48, "$/"
-    unless_null $P48, vivify_38
+    unless_null $P48, vivify_40
     new $P48, "Undef"
-  vivify_38:
+  vivify_40:
     $P49 = $P45."new"($P47 :named("name"), $P48 :named("node"))
     .lex "$past", $P49
     get_hll_global $P50, ["PAST"], "Op"
     assign $P51, ""
     find_lex $P52, "$/"
     set $P53, $P52["roman"]
-    unless_null $P53, vivify_39
+    unless_null $P53, vivify_41
     new $P53, "Undef"
-  vivify_39:
+  vivify_41:
     concat $P54, $P51, $P53
     concat $P55, $P54, ":"
     find_lex $P56, "$/"
-    unless_null $P56, vivify_40
+    unless_null $P56, vivify_42
     new $P56, "Undef"
-  vivify_40:
+  vivify_42:
     $P57 = $P50."new"($P55 :named("inline"), $P56 :named("node"))
     .lex "$lbl", $P57
     find_lex $P58, "$past"
-    unless_null $P58, vivify_41
+    unless_null $P58, vivify_43
     new $P58, "Undef"
-  vivify_41:
+  vivify_43:
     find_lex $P59, "$lbl"
-    unless_null $P59, vivify_42
+    unless_null $P59, vivify_44
     new $P59, "Undef"
-  vivify_42:
+  vivify_44:
     $P58."push"($P59)
     find_lex $P61, "$/"
     set $P62, $P61["line"]
-    unless_null $P62, vivify_43
+    unless_null $P62, vivify_45
     new $P62, "Undef"
-  vivify_43:
+  vivify_45:
     defined $I63, $P62
-    unless $I63, for_undef_44
+    unless $I63, for_undef_46
     iter $P60, $P62
     new $P73, 'ExceptionHandler'
     set_addr $P73, loop72_handler
     eq $P74, 66, loop72_redo
   loop72_done:
     pop_eh 
-  for_undef_44:
+  for_undef_46:
     find_lex $P75, "$/"
     find_lex $P76, "$past"
-    unless_null $P76, vivify_47
+    unless_null $P76, vivify_49
     new $P76, "Undef"
-  vivify_47:
+  vivify_49:
     $P77 = $P75."result_object"($P76)
     .return ($P77)
   control_42:
     .param pmc param_67
     .lex "$_", param_67
     find_lex $P68, "$past"
-    unless_null $P68, vivify_45
+    unless_null $P68, vivify_47
     new $P68, "Undef"
-  vivify_45:
+  vivify_47:
     find_lex $P69, "$_"
-    unless_null $P69, vivify_46
+    unless_null $P69, vivify_48
     new $P69, "Undef"
-  vivify_46:
+  vivify_48:
     $P70 = $P69."item"()
     $P71 = $P68."push"($P70)
     .return ($P71)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "branch"  :subid("15") :method :outer("30")
+.sub "branch"  :subid("15") :method :outer("32")
     .param pmc param_82
     new $P81, 'ExceptionHandler'
     set_addr $P81, control_80
     assign $P83, "branch:"
     find_lex $P84, "$/"
     set $P85, $P84["roman"]
-    unless_null $P85, vivify_48
+    unless_null $P85, vivify_50
     new $P85, "Undef"
-  vivify_48:
+  vivify_50:
     concat $P86, $P83, $P85
-    "say"($P86)
+    "dbg"($P86)
     get_hll_global $P87, ["PAST"], "Op"
     new $P88, "String"
     assign $P88, "goto "
     find_lex $P89, "$/"
     set $P90, $P89["roman"]
-    unless_null $P90, vivify_49
+    unless_null $P90, vivify_51
     new $P90, "Undef"
-  vivify_49:
+  vivify_51:
     concat $P91, $P88, $P90
     find_lex $P92, "$/"
-    unless_null $P92, vivify_50
+    unless_null $P92, vivify_52
     new $P92, "Undef"
-  vivify_50:
+  vivify_52:
     $P93 = $P87."new"($P91 :named("inline"), $P92 :named("node"))
     .lex "$res", $P93
     find_lex $P94, "$/"
     find_lex $P95, "$res"
-    unless_null $P95, vivify_51
+    unless_null $P95, vivify_53
     new $P95, "Undef"
-  vivify_51:
+  vivify_53:
     $P96 = $P94."result_object"($P95)
     .return ($P96)
   control_80:
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "io"  :subid("16") :method :outer("30")
+.sub "io"  :subid("16") :method :outer("32")
     .param pmc param_101
     .param pmc param_102
     new $P100, 'ExceptionHandler'
     new $P103, "String"
     assign $P103, "io:"
     find_lex $P104, "$key"
-    unless_null $P104, vivify_52
+    unless_null $P104, vivify_54
     new $P104, "Undef"
-  vivify_52:
+  vivify_54:
     concat $P105, $P103, $P104
-    "say"($P105)
+    "dbg"($P105)
     get_hll_global $P106, ["PAST"], "Op"
     find_lex $P107, "$/"
-    unless_null $P107, vivify_53
+    unless_null $P107, vivify_55
     new $P107, "Undef"
-  vivify_53:
+  vivify_55:
     $P108 = $P106."new"("say2" :named("name"), "call" :named("pasttype"), $P107 :named("node"))
     .lex "$res", $P108
-    "say"("ok")
+    "dbg"("ok")
     find_lex $P109, "$/"
     find_lex $P110, "$res"
-    unless_null $P110, vivify_54
+    unless_null $P110, vivify_56
     new $P110, "Undef"
-  vivify_54:
+  vivify_56:
     $P111 = $P109."result_object"($P110)
     .return ($P111)
   control_99:
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "line"  :subid("17") :method :outer("30")
+.sub "line"  :subid("17") :method :outer("32")
     .param pmc param_116
     new $P115, 'ExceptionHandler'
     set_addr $P115, control_114
     .lex "$/", param_116
     get_hll_global $P117, ["PAST"], "Stmts"
     find_lex $P118, "$/"
-    unless_null $P118, vivify_55
+    unless_null $P118, vivify_57
     new $P118, "Undef"
-  vivify_55:
+  vivify_57:
     $P119 = $P117."new"($P118 :named("node"))
     .lex "$past", $P119
     find_lex $P121, "$/"
     set $P122, $P121["sentence"]
-    unless_null $P122, vivify_56
+    unless_null $P122, vivify_58
     new $P122, "Undef"
-  vivify_56:
+  vivify_58:
     defined $I123, $P122
-    unless $I123, for_undef_57
+    unless $I123, for_undef_59
     iter $P120, $P122
     new $P133, 'ExceptionHandler'
     set_addr $P133, loop132_handler
     eq $P134, 66, loop132_redo
   loop132_done:
     pop_eh 
-  for_undef_57:
+  for_undef_59:
     find_lex $P135, "$/"
     find_lex $P136, "$past"
-    unless_null $P136, vivify_60
+    unless_null $P136, vivify_62
     new $P136, "Undef"
-  vivify_60:
+  vivify_62:
     $P137 = $P135."result_object"($P136)
     .return ($P137)
   control_114:
     .param pmc param_127
     .lex "$_", param_127
     find_lex $P128, "$past"
-    unless_null $P128, vivify_58
+    unless_null $P128, vivify_60
     new $P128, "Undef"
-  vivify_58:
+  vivify_60:
     find_lex $P129, "$_"
-    unless_null $P129, vivify_59
+    unless_null $P129, vivify_61
     new $P129, "Undef"
-  vivify_59:
+  vivify_61:
     $P130 = $P129."item"()
     $P131 = $P128."push"($P130)
     .return ($P131)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "sentence"  :subid("19") :method :outer("30")
+.sub "sentence"  :subid("19") :method :outer("32")
     .param pmc param_142
     .param pmc param_143
     new $P141, 'ExceptionHandler'
     new $P144, "String"
     assign $P144, "sentence:"
     find_lex $P145, "$key"
-    unless_null $P145, vivify_61
+    unless_null $P145, vivify_63
     new $P145, "Undef"
-  vivify_61:
+  vivify_63:
     concat $P146, $P144, $P145
-    "say"($P146)
+    "dbg"($P146)
     find_lex $P147, "$/"
     find_lex $P148, "$key"
-    unless_null $P148, vivify_62
+    unless_null $P148, vivify_64
     new $P148, "Undef"
-  vivify_62:
+  vivify_64:
     find_lex $P149, "$/"
-    unless_null $P149, vivify_63
+    unless_null $P149, vivify_65
     new $P149, "Hash"
-  vivify_63:
+  vivify_65:
     set $P150, $P149[$P148]
-    unless_null $P150, vivify_64
+    unless_null $P150, vivify_66
     new $P150, "Undef"
-  vivify_64:
+  vivify_66:
     $P151 = $P150."item"()
     $P152 = $P147."result_object"($P151)
     .return ($P152)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "value"  :subid("20") :method :outer("30")
+.sub "dbg"  :subid("20") :outer("32")
     .param pmc param_157
-    .param pmc param_158
     new $P156, 'ExceptionHandler'
     set_addr $P156, control_155
     $P156."handle_types"(58)
     push_eh $P156
-    .lex "$/", param_157
-    .lex "$key", param_158
-    find_lex $P159, "$/"
-    find_lex $P160, "$key"
-    unless_null $P160, vivify_65
-    new $P160, "Undef"
-  vivify_65:
-    find_lex $P161, "$/"
-    unless_null $P161, vivify_66
-    new $P161, "Hash"
-  vivify_66:
-    set $P162, $P161[$P160]
-    unless_null $P162, vivify_67
-    new $P162, "Undef"
-  vivify_67:
-    $P163 = $P162."item"()
-    $P164 = $P159."result_object"($P163)
-    .return ($P164)
+    .lex "$str", param_157
+    new $P160, "Integer"
+    assign $P160, 0
+    if $P160, if_159
+    set $P158, $P160
+    goto if_159_end
+  if_159:
+    .const 'Sub' $P162 = "21" 
+    capture_lex $P162
+    $P165 = $P162()
+    set $P158, $P165
+  if_159_end:
+    .return ($P158)
   control_155:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P165, exception, "payload"
-    .return ($P165)
+    getattribute $P166, exception, "payload"
+    .return ($P166)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "question"  :subid("21") :method :outer("30")
-    .param pmc param_169
+.sub "_block161"  :anon :subid("21") :outer("20")
+    find_lex $P163, "$str"
+    unless_null $P163, vivify_67
+    new $P163, "Undef"
+  vivify_67:
+    $P164 = "say"($P163)
+    .return ($P164)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "value"  :subid("22") :method :outer("32")
     .param pmc param_170
-    new $P168, 'ExceptionHandler'
-    set_addr $P168, control_167
-    $P168."handle_types"(58)
-    push_eh $P168
-    .lex "$/", param_169
-    .lex "$key", param_170
-    get_hll_global $P171, ["PAST"], "Op"
-    find_lex $P172, "$key"
-    unless_null $P172, vivify_68
-    new $P172, "Undef"
+    .param pmc param_171
+    new $P169, 'ExceptionHandler'
+    set_addr $P169, control_168
+    $P169."handle_types"(58)
+    push_eh $P169
+    .lex "$/", param_170
+    .lex "$key", param_171
+    find_lex $P172, "$/"
+    find_lex $P173, "$key"
+    unless_null $P173, vivify_68
+    new $P173, "Undef"
   vivify_68:
-    find_lex $P173, "$/"
-    unless_null $P173, vivify_69
-    new $P173, "Undef"
+    find_lex $P174, "$/"
+    unless_null $P174, vivify_69
+    new $P174, "Hash"
   vivify_69:
-    $P174 = $P171."new"($P172 :named("name"), "call" :named("pasttype"), $P173 :named("node"))
-    .lex "$res", $P174
-    find_lex $P176, "$/"
-    set $P177, $P176["value"]
-    unless_null $P177, vivify_70
-    new $P177, "Undef"
+    set $P175, $P174[$P173]
+    unless_null $P175, vivify_70
+    new $P175, "Undef"
   vivify_70:
-    defined $I178, $P177
-    unless $I178, for_undef_71
-    iter $P175, $P177
-    new $P188, 'ExceptionHandler'
-    set_addr $P188, loop187_handler
-    $P188."handle_types"(64, 66, 65)
-    push_eh $P188
-  loop187_test:
-    unless $P175, loop187_done
-    shift $P179, $P175
-  loop187_redo:
-    .const 'Sub' $P181 = "22" 
-    capture_lex $P181
-    $P181($P179)
-  loop187_next:
-    goto loop187_test
-  loop187_handler:
+    $P176 = $P175."item"()
+    $P177 = $P172."result_object"($P176)
+    .return ($P177)
+  control_168:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P189, exception, 'type'
-    eq $P189, 64, loop187_next
-    eq $P189, 66, loop187_redo
-  loop187_done:
-    pop_eh 
-  for_undef_71:
-    find_lex $P190, "$/"
-    find_lex $P191, "$res"
-    unless_null $P191, vivify_74
-    new $P191, "Undef"
-  vivify_74:
-    $P192 = $P190."result_object"($P191)
-    .return ($P192)
-  control_167:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P193, exception, "payload"
-    .return ($P193)
+    getattribute $P178, exception, "payload"
+    .return ($P178)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block180"  :anon :subid("22") :outer("21")
+.sub "question"  :subid("23") :method :outer("32")
     .param pmc param_182
-    .lex "$_", param_182
-    find_lex $P183, "$res"
-    unless_null $P183, vivify_72
-    new $P183, "Undef"
+    .param pmc param_183
+    new $P181, 'ExceptionHandler'
+    set_addr $P181, control_180
+    $P181."handle_types"(58)
+    push_eh $P181
+    .lex "$/", param_182
+    .lex "$key", param_183
+    get_hll_global $P184, ["PAST"], "Op"
+    find_lex $P185, "$key"
+    unless_null $P185, vivify_71
+    new $P185, "Undef"
+  vivify_71:
+    find_lex $P186, "$/"
+    unless_null $P186, vivify_72
+    new $P186, "Undef"
   vivify_72:
-    find_lex $P184, "$_"
-    unless_null $P184, vivify_73
-    new $P184, "Undef"
+    $P187 = $P184."new"($P185 :named("name"), "call" :named("pasttype"), $P186 :named("node"))
+    .lex "$res", $P187
+    find_lex $P189, "$/"
+    set $P190, $P189["value"]
+    unless_null $P190, vivify_73
+    new $P190, "Undef"
   vivify_73:
-    $P185 = $P184."item"()
-    $P186 = $P183."push"($P185)
-    .return ($P186)
+    defined $I191, $P190
+    unless $I191, for_undef_74
+    iter $P188, $P190
+    new $P201, 'ExceptionHandler'
+    set_addr $P201, loop200_handler
+    $P201."handle_types"(64, 66, 65)
+    push_eh $P201
+  loop200_test:
+    unless $P188, loop200_done
+    shift $P192, $P188
+  loop200_redo:
+    .const 'Sub' $P194 = "24" 
+    capture_lex $P194
+    $P194($P192)
+  loop200_next:
+    goto loop200_test
+  loop200_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P202, exception, 'type'
+    eq $P202, 64, loop200_next
+    eq $P202, 66, loop200_redo
+  loop200_done:
+    pop_eh 
+  for_undef_74:
+    find_lex $P203, "$/"
+    find_lex $P204, "$res"
+    unless_null $P204, vivify_77
+    new $P204, "Undef"
+  vivify_77:
+    $P205 = $P203."result_object"($P204)
+    .return ($P205)
+  control_180:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P206, exception, "payload"
+    .return ($P206)
+    rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "immediate"  :subid("23") :method :outer("30")
-    .param pmc param_197
-    new $P196, 'ExceptionHandler'
-    set_addr $P196, control_195
-    $P196."handle_types"(58)
-    push_eh $P196
-    .lex "$/", param_197
-    new $P198, "Integer"
-    assign $P198, 1
-    .lex "$value", $P198
-    find_lex $P200, "$/"
-    set $P201, $P200["adjective"]
-    unless_null $P201, vivify_75
-    new $P201, "Undef"
+.sub "_block193"  :anon :subid("24") :outer("23")
+    .param pmc param_195
+    .lex "$_", param_195
+    find_lex $P196, "$res"
+    unless_null $P196, vivify_75
+    new $P196, "Undef"
   vivify_75:
-    defined $I202, $P201
-    unless $I202, for_undef_76
-    iter $P199, $P201
-    new $P210, 'ExceptionHandler'
-    set_addr $P210, loop209_handler
-    $P210."handle_types"(64, 66, 65)
-    push_eh $P210
-  loop209_test:
-    unless $P199, loop209_done
-    shift $P203, $P199
-  loop209_redo:
-    .const 'Sub' $P205 = "24" 
-    capture_lex $P205
-    $P205($P203)
-  loop209_next:
-    goto loop209_test
-  loop209_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P211, exception, 'type'
-    eq $P211, 64, loop209_next
-    eq $P211, 66, loop209_redo
-  loop209_done:
-    pop_eh 
-  for_undef_76:
-    find_lex $P212, "$/"
-    get_hll_global $P213, ["PAST"], "Val"
-    find_lex $P214, "$value"
+    find_lex $P197, "$_"
+    unless_null $P197, vivify_76
+    new $P197, "Undef"
+  vivify_76:
+    $P198 = $P197."item"()
+    $P199 = $P196."push"($P198)
+    .return ($P199)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "immediate"  :subid("25") :method :outer("32")
+    .param pmc param_210
+    new $P209, 'ExceptionHandler'
+    set_addr $P209, control_208
+    $P209."handle_types"(58)
+    push_eh $P209
+    .lex "$/", param_210
+    new $P211, "Integer"
+    assign $P211, 1
+    .lex "$value", $P211
+    find_lex $P213, "$/"
+    set $P214, $P213["adjective"]
     unless_null $P214, vivify_78
     new $P214, "Undef"
   vivify_78:
-    find_lex $P215, "$/"
-    unless_null $P215, vivify_79
-    new $P215, "Undef"
-  vivify_79:
-    $P216 = $P213."new"($P214 :named("value"), "Integer" :named("returns"), $P215 :named("node"))
-    $P217 = $P212."result_object"($P216)
-    .return ($P217)
-  control_195:
+    defined $I215, $P214
+    unless $I215, for_undef_79
+    iter $P212, $P214
+    new $P223, 'ExceptionHandler'
+    set_addr $P223, loop222_handler
+    $P223."handle_types"(64, 66, 65)
+    push_eh $P223
+  loop222_test:
+    unless $P212, loop222_done
+    shift $P216, $P212
+  loop222_redo:
+    .const 'Sub' $P218 = "26" 
+    capture_lex $P218
+    $P218($P216)
+  loop222_next:
+    goto loop222_test
+  loop222_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P218, exception, "payload"
-    .return ($P218)
+    getattribute $P224, exception, 'type'
+    eq $P224, 64, loop222_next
+    eq $P224, 66, loop222_redo
+  loop222_done:
+    pop_eh 
+  for_undef_79:
+    find_lex $P225, "$/"
+    get_hll_global $P226, ["PAST"], "Val"
+    find_lex $P227, "$value"
+    unless_null $P227, vivify_81
+    new $P227, "Undef"
+  vivify_81:
+    find_lex $P228, "$/"
+    unless_null $P228, vivify_82
+    new $P228, "Undef"
+  vivify_82:
+    $P229 = $P226."new"($P227 :named("value"), "Integer" :named("returns"), $P228 :named("node"))
+    $P230 = $P225."result_object"($P229)
+    .return ($P230)
+  control_208:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P231, exception, "payload"
+    .return ($P231)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block204"  :anon :subid("24") :outer("23")
-    .param pmc param_206
-    .lex "$_", param_206
-    find_lex $P207, "$value"
-    unless_null $P207, vivify_77
-    new $P207, "Undef"
-  vivify_77:
-    mul $P208, $P207, 2
-    store_lex "$value", $P208
-    .return ($P208)
+.sub "_block217"  :anon :subid("26") :outer("25")
+    .param pmc param_219
+    .lex "$_", param_219
+    find_lex $P220, "$value"
+    unless_null $P220, vivify_80
+    new $P220, "Undef"
+  vivify_80:
+    mul $P221, $P220, 2
+    store_lex "$value", $P221
+    .return ($P221)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "test"  :subid("25") :method :outer("30")
-    .param pmc param_222
-    .param pmc param_223
-    new $P221, 'ExceptionHandler'
-    set_addr $P221, control_220
-    $P221."handle_types"(58)
-    push_eh $P221
-    .lex "$/", param_222
-    .lex "$k", param_223
-    find_lex $P224, "$/"
-    get_hll_global $P225, ["PAST"], "Val"
-    find_lex $P226, "$k"
-    unless_null $P226, vivify_80
-    new $P226, "Undef"
-  vivify_80:
-    find_lex $P227, "$/"
-    unless_null $P227, vivify_81
-    new $P227, "Undef"
-  vivify_81:
-    $P228 = $P225."new"($P226 :named("value"), "String" :named("returns"), $P227 :named("node"))
-    $P229 = $P224."result_object"($P228)
-    .return ($P229)
-  control_220:
+.sub "test"  :subid("27") :method :outer("32")
+    .param pmc param_235
+    .param pmc param_236
+    new $P234, 'ExceptionHandler'
+    set_addr $P234, control_233
+    $P234."handle_types"(58)
+    push_eh $P234
+    .lex "$/", param_235
+    .lex "$k", param_236
+    find_lex $P237, "$/"
+    get_hll_global $P238, ["PAST"], "Val"
+    find_lex $P239, "$k"
+    unless_null $P239, vivify_83
+    new $P239, "Undef"
+  vivify_83:
+    find_lex $P240, "$/"
+    unless_null $P240, vivify_84
+    new $P240, "Undef"
+  vivify_84:
+    $P241 = $P238."new"($P239 :named("value"), "String" :named("returns"), $P240 :named("node"))
+    $P242 = $P237."result_object"($P241)
+    .return ($P242)
+  control_233:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P230, exception, "payload"
-    .return ($P230)
+    getattribute $P243, exception, "payload"
+    .return ($P243)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "computation"  :subid("26") :method :outer("30")
-    .param pmc param_234
-    .param pmc param_235
-    new $P233, 'ExceptionHandler'
-    set_addr $P233, control_232
-    $P233."handle_types"(58)
-    push_eh $P233
-    .lex "$/", param_234
-    .lex "$key", param_235
-    find_lex $P236, "$/"
-    find_lex $P237, "$key"
-    unless_null $P237, vivify_82
-    new $P237, "Undef"
-  vivify_82:
-    find_lex $P238, "$/"
-    unless_null $P238, vivify_83
-    new $P238, "Hash"
-  vivify_83:
-    set $P239, $P238[$P237]
-    unless_null $P239, vivify_84
-    new $P239, "Undef"
-  vivify_84:
-    $P240 = $P239."item"()
-    $P241 = $P236."result_object"($P240)
-    .return ($P241)
-  control_232:
+.sub "computation"  :subid("28") :method :outer("32")
+    .param pmc param_247
+    .param pmc param_248
+    new $P246, 'ExceptionHandler'
+    set_addr $P246, control_245
+    $P246."handle_types"(58)
+    push_eh $P246
+    .lex "$/", param_247
+    .lex "$key", param_248
+    find_lex $P249, "$/"
+    find_lex $P250, "$key"
+    unless_null $P250, vivify_85
+    new $P250, "Undef"
+  vivify_85:
+    find_lex $P251, "$/"
+    unless_null $P251, vivify_86
+    new $P251, "Hash"
+  vivify_86:
+    set $P252, $P251[$P250]
+    unless_null $P252, vivify_87
+    new $P252, "Undef"
+  vivify_87:
+    $P253 = $P252."item"()
+    $P254 = $P249."result_object"($P253)
+    .return ($P254)
+  control_245:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P242, exception, "payload"
-    .return ($P242)
+    getattribute $P255, exception, "payload"
+    .return ($P255)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "unary"  :subid("27") :method :outer("30")
-    .param pmc param_246
-    .param pmc param_247
-    new $P245, 'ExceptionHandler'
-    set_addr $P245, control_244
-    $P245."handle_types"(58)
-    push_eh $P245
-    .lex "$/", param_246
-    .lex "$key", param_247
-    get_hll_global $P248, ["PAST"], "Op"
-    find_lex $P249, "$key"
-    unless_null $P249, vivify_85
-    new $P249, "Undef"
-  vivify_85:
-    find_lex $P250, "$/"
-    unless_null $P250, vivify_86
-    new $P250, "Undef"
-  vivify_86:
-    $P251 = $P248."new"($P249 :named("name"), "call" :named("pasttype"), $P250 :named("node"))
-    .lex "$res", $P251
-    find_lex $P252, "$res"
-    unless_null $P252, vivify_87
-    new $P252, "Undef"
-  vivify_87:
-    find_lex $P253, "$/"
-    set $P254, $P253["value"]
-    unless_null $P254, vivify_88
-    new $P254, "Undef"
+.sub "unary"  :subid("29") :method :outer("32")
+    .param pmc param_259
+    .param pmc param_260
+    new $P258, 'ExceptionHandler'
+    set_addr $P258, control_257
+    $P258."handle_types"(58)
+    push_eh $P258
+    .lex "$/", param_259
+    .lex "$key", param_260
+    get_hll_global $P261, ["PAST"], "Op"
+    find_lex $P262, "$key"
+    unless_null $P262, vivify_88
+    new $P262, "Undef"
   vivify_88:
-    $P255 = $P254."item"()
-    $P252."push"($P255)
-    find_lex $P256, "$/"
-    find_lex $P257, "$res"
-    unless_null $P257, vivify_89
-    new $P257, "Undef"
+    find_lex $P263, "$/"
+    unless_null $P263, vivify_89
+    new $P263, "Undef"
   vivify_89:
-    $P258 = $P256."result_object"($P257)
-    .return ($P258)
-  control_244:
+    $P264 = $P261."new"($P262 :named("name"), "call" :named("pasttype"), $P263 :named("node"))
+    .lex "$res", $P264
+    find_lex $P265, "$res"
+    unless_null $P265, vivify_90
+    new $P265, "Undef"
+  vivify_90:
+    find_lex $P266, "$/"
+    set $P267, $P266["value"]
+    unless_null $P267, vivify_91
+    new $P267, "Undef"
+  vivify_91:
+    $P268 = $P267."item"()
+    $P265."push"($P268)
+    find_lex $P269, "$/"
+    find_lex $P270, "$res"
+    unless_null $P270, vivify_92
+    new $P270, "Undef"
+  vivify_92:
+    $P271 = $P269."result_object"($P270)
+    .return ($P271)
+  control_257:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P259, exception, "payload"
-    .return ($P259)
+    getattribute $P272, exception, "payload"
+    .return ($P272)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "binary"  :subid("28") :method :outer("30")
-    .param pmc param_263
-    .param pmc param_264
-    new $P262, 'ExceptionHandler'
-    set_addr $P262, control_261
-    $P262."handle_types"(58)
-    push_eh $P262
-    .lex "$/", param_263
-    .lex "$key", param_264
-    get_hll_global $P265, ["PAST"], "Op"
-    find_lex $P266, "$key"
-    unless_null $P266, vivify_90
-    new $P266, "Undef"
-  vivify_90:
-    find_lex $P267, "$/"
-    unless_null $P267, vivify_91
-    new $P267, "Undef"
-  vivify_91:
-    $P268 = $P265."new"($P266 :named("name"), "call" :named("pasttype"), $P267 :named("node"))
-    .lex "$res", $P268
-    find_lex $P270, "$/"
-    set $P271, $P270["value"]
-    unless_null $P271, vivify_92
-    new $P271, "Undef"
-  vivify_92:
-    defined $I272, $P271
-    unless $I272, for_undef_93
-    iter $P269, $P271
-    new $P282, 'ExceptionHandler'
-    set_addr $P282, loop281_handler
-    $P282."handle_types"(64, 66, 65)
-    push_eh $P282
-  loop281_test:
-    unless $P269, loop281_done
-    shift $P273, $P269
-  loop281_redo:
-    .const 'Sub' $P275 = "29" 
-    capture_lex $P275
-    $P275($P273)
-  loop281_next:
-    goto loop281_test
-  loop281_handler:
+.sub "binary"  :subid("30") :method :outer("32")
+    .param pmc param_276
+    .param pmc param_277
+    new $P275, 'ExceptionHandler'
+    set_addr $P275, control_274
+    $P275."handle_types"(58)
+    push_eh $P275
+    .lex "$/", param_276
+    .lex "$key", param_277
+    get_hll_global $P278, ["PAST"], "Op"
+    find_lex $P279, "$key"
+    unless_null $P279, vivify_93
+    new $P279, "Undef"
+  vivify_93:
+    find_lex $P280, "$/"
+    unless_null $P280, vivify_94
+    new $P280, "Undef"
+  vivify_94:
+    $P281 = $P278."new"($P279 :named("name"), "call" :named("pasttype"), $P280 :named("node"))
+    .lex "$res", $P281
+    find_lex $P283, "$/"
+    set $P284, $P283["value"]
+    unless_null $P284, vivify_95
+    new $P284, "Undef"
+  vivify_95:
+    defined $I285, $P284
+    unless $I285, for_undef_96
+    iter $P282, $P284
+    new $P295, 'ExceptionHandler'
+    set_addr $P295, loop294_handler
+    $P295."handle_types"(64, 66, 65)
+    push_eh $P295
+  loop294_test:
+    unless $P282, loop294_done
+    shift $P286, $P282
+  loop294_redo:
+    .const 'Sub' $P288 = "31" 
+    capture_lex $P288
+    $P288($P286)
+  loop294_next:
+    goto loop294_test
+  loop294_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P283, exception, 'type'
-    eq $P283, 64, loop281_next
-    eq $P283, 66, loop281_redo
-  loop281_done:
+    getattribute $P296, exception, 'type'
+    eq $P296, 64, loop294_next
+    eq $P296, 66, loop294_redo
+  loop294_done:
     pop_eh 
-  for_undef_93:
-    find_lex $P284, "$/"
-    find_lex $P285, "$res"
-    unless_null $P285, vivify_96
-    new $P285, "Undef"
-  vivify_96:
-    $P286 = $P284."result_object"($P285)
-    .return ($P286)
-  control_261:
+  for_undef_96:
+    find_lex $P297, "$/"
+    find_lex $P298, "$res"
+    unless_null $P298, vivify_99
+    new $P298, "Undef"
+  vivify_99:
+    $P299 = $P297."result_object"($P298)
+    .return ($P299)
+  control_274:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P287, exception, "payload"
-    .return ($P287)
+    getattribute $P300, exception, "payload"
+    .return ($P300)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block274"  :anon :subid("29") :outer("28")
-    .param pmc param_276
-    .lex "$_", param_276
-    find_lex $P277, "$res"
-    unless_null $P277, vivify_94
-    new $P277, "Undef"
-  vivify_94:
-    find_lex $P278, "$_"
-    unless_null $P278, vivify_95
-    new $P278, "Undef"
-  vivify_95:
-    $P279 = $P278."item"()
-    $P280 = $P277."push"($P279)
-    .return ($P280)
+.sub "_block287"  :anon :subid("31") :outer("30")
+    .param pmc param_289
+    .lex "$_", param_289
+    find_lex $P290, "$res"
+    unless_null $P290, vivify_97
+    new $P290, "Undef"
+  vivify_97:
+    find_lex $P291, "$_"
+    unless_null $P291, vivify_98
+    new $P291, "Undef"
+  vivify_98:
+    $P292 = $P291."item"()
+    $P293 = $P290."push"($P292)
+    .return ($P293)
 .end
 

File src/parser/actions.pm

 }
 
 method branch($/) {
-  say("branch:"~$<roman>);
+  dbg("branch:"~$<roman>);
   my $res := PAST::Op.new( 
     :inline("goto "~$<roman>), 
     :node( $/ ) );
 }
 
 method io($/,$key) {
-  say("io:"~$key);
+  dbg("io:"~$key);
   my $res := PAST::Op.new(:name('say2'),:pasttype('call'),:node($/));
-  say("ok");
+  dbg("ok");
   make $res;
 }
 
     make $past;
 }
 method sentence($/, $key) {
-    say("sentence:"~$key);
+    dbg("sentence:"~$key);
   make $( $/{$key} );
 }
 
+sub dbg($str) {
+  if (0) {
+    say($str);
+  }
+}
 
 method value($/, $key) {
   make $( $/{$key} );

File z2.pbc

Binary file modified.