Commits

Anonymous committed 28cde2a

conditions are set, branche is parsed but does not work

Comments (0)

Files changed (9)

src/gen_actions.pir

 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block13" :init :load :subid("27")
-    .const 'Sub' $P220 = "25" 
-    capture_lex $P220
-    .const 'Sub' $P203 = "24" 
-    capture_lex $P203
-    .const 'Sub' $P191 = "23" 
-    capture_lex $P191
+.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
     .const 'Sub' $P154 = "20" 
         $P2 = $P0.'new_class'($P1)
       subclass_done:
         pop_eh
-    .const 'Sub' $P220 = "25" 
-    capture_lex $P220
-    .return ($P220)
+    .const 'Sub' $P260 = "28" 
+    capture_lex $P260
+    .return ($P260)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "TOP"  :subid("11") :method :outer("27")
+.sub "TOP"  :subid("11") :method :outer("30")
     .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_28
+    unless_null $P20, vivify_31
     new $P20, "Undef"
-  vivify_28:
+  vivify_31:
     $P21 = $P19."new"($P20 :named("node"))
     .lex "$past", $P21
     find_lex $P23, "$/"
     set $P24, $P23["scene"]
-    unless_null $P24, vivify_29
+    unless_null $P24, vivify_32
     new $P24, "Undef"
-  vivify_29:
+  vivify_32:
     defined $I25, $P24
-    unless $I25, for_undef_30
+    unless $I25, for_undef_33
     iter $P22, $P24
     new $P35, 'ExceptionHandler'
     set_addr $P35, loop34_handler
     eq $P36, 66, loop34_redo
   loop34_done:
     pop_eh 
-  for_undef_30:
+  for_undef_33:
     find_lex $P37, "$/"
     find_lex $P38, "$past"
-    unless_null $P38, vivify_33
+    unless_null $P38, vivify_36
     new $P38, "Undef"
-  vivify_33:
+  vivify_36:
     $P39 = $P37."result_object"($P38)
     .return ($P39)
   control_16:
     .param pmc param_29
     .lex "$_", param_29
     find_lex $P30, "$past"
-    unless_null $P30, vivify_31
+    unless_null $P30, vivify_34
     new $P30, "Undef"
-  vivify_31:
+  vivify_34:
     find_lex $P31, "$_"
-    unless_null $P31, vivify_32
+    unless_null $P31, vivify_35
     new $P31, "Undef"
-  vivify_32:
+  vivify_35:
     $P32 = $P31."item"()
     $P33 = $P30."push"($P32)
     .return ($P33)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "scene"  :subid("13") :method :outer("27")
+.sub "scene"  :subid("13") :method :outer("30")
     .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_34
+    unless_null $P47, vivify_37
     new $P47, "Undef"
-  vivify_34:
+  vivify_37:
     find_lex $P48, "$/"
-    unless_null $P48, vivify_35
+    unless_null $P48, vivify_38
     new $P48, "Undef"
-  vivify_35:
+  vivify_38:
     $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_36
+    unless_null $P53, vivify_39
     new $P53, "Undef"
-  vivify_36:
+  vivify_39:
     concat $P54, $P51, $P53
     concat $P55, $P54, ":"
     find_lex $P56, "$/"
-    unless_null $P56, vivify_37
+    unless_null $P56, vivify_40
     new $P56, "Undef"
-  vivify_37:
+  vivify_40:
     $P57 = $P50."new"($P55 :named("inline"), $P56 :named("node"))
     .lex "$lbl", $P57
     find_lex $P58, "$past"
-    unless_null $P58, vivify_38
+    unless_null $P58, vivify_41
     new $P58, "Undef"
-  vivify_38:
+  vivify_41:
     find_lex $P59, "$lbl"
-    unless_null $P59, vivify_39
+    unless_null $P59, vivify_42
     new $P59, "Undef"
-  vivify_39:
+  vivify_42:
     $P58."push"($P59)
     find_lex $P61, "$/"
     set $P62, $P61["line"]
-    unless_null $P62, vivify_40
+    unless_null $P62, vivify_43
     new $P62, "Undef"
-  vivify_40:
+  vivify_43:
     defined $I63, $P62
-    unless $I63, for_undef_41
+    unless $I63, for_undef_44
     iter $P60, $P62
     new $P73, 'ExceptionHandler'
     set_addr $P73, loop72_handler
     eq $P74, 66, loop72_redo
   loop72_done:
     pop_eh 
-  for_undef_41:
+  for_undef_44:
     find_lex $P75, "$/"
     find_lex $P76, "$past"
-    unless_null $P76, vivify_44
+    unless_null $P76, vivify_47
     new $P76, "Undef"
-  vivify_44:
+  vivify_47:
     $P77 = $P75."result_object"($P76)
     .return ($P77)
   control_42:
     .param pmc param_67
     .lex "$_", param_67
     find_lex $P68, "$past"
-    unless_null $P68, vivify_42
+    unless_null $P68, vivify_45
     new $P68, "Undef"
-  vivify_42:
+  vivify_45:
     find_lex $P69, "$_"
-    unless_null $P69, vivify_43
+    unless_null $P69, vivify_46
     new $P69, "Undef"
-  vivify_43:
+  vivify_46:
     $P70 = $P69."item"()
     $P71 = $P68."push"($P70)
     .return ($P71)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "branch"  :subid("15") :method :outer("27")
+.sub "branch"  :subid("15") :method :outer("30")
     .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_45
+    unless_null $P85, vivify_48
     new $P85, "Undef"
-  vivify_45:
+  vivify_48:
     concat $P86, $P83, $P85
     "say"($P86)
     get_hll_global $P87, ["PAST"], "Op"
     assign $P88, "goto "
     find_lex $P89, "$/"
     set $P90, $P89["roman"]
-    unless_null $P90, vivify_46
+    unless_null $P90, vivify_49
     new $P90, "Undef"
-  vivify_46:
+  vivify_49:
     concat $P91, $P88, $P90
     find_lex $P92, "$/"
-    unless_null $P92, vivify_47
+    unless_null $P92, vivify_50
     new $P92, "Undef"
-  vivify_47:
+  vivify_50:
     $P93 = $P87."new"($P91 :named("inline"), $P92 :named("node"))
     .lex "$res", $P93
     find_lex $P94, "$/"
     find_lex $P95, "$res"
-    unless_null $P95, vivify_48
+    unless_null $P95, vivify_51
     new $P95, "Undef"
-  vivify_48:
+  vivify_51:
     $P96 = $P94."result_object"($P95)
     .return ($P96)
   control_80:
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "io"  :subid("16") :method :outer("27")
+.sub "io"  :subid("16") :method :outer("30")
     .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_49
+    unless_null $P104, vivify_52
     new $P104, "Undef"
-  vivify_49:
+  vivify_52:
     concat $P105, $P103, $P104
     "say"($P105)
     get_hll_global $P106, ["PAST"], "Op"
     find_lex $P107, "$/"
-    unless_null $P107, vivify_50
+    unless_null $P107, vivify_53
     new $P107, "Undef"
-  vivify_50:
+  vivify_53:
     $P108 = $P106."new"("say2" :named("name"), "call" :named("pasttype"), $P107 :named("node"))
     .lex "$res", $P108
     "say"("ok")
     find_lex $P109, "$/"
     find_lex $P110, "$res"
-    unless_null $P110, vivify_51
+    unless_null $P110, vivify_54
     new $P110, "Undef"
-  vivify_51:
+  vivify_54:
     $P111 = $P109."result_object"($P110)
     .return ($P111)
   control_99:
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "line"  :subid("17") :method :outer("27")
+.sub "line"  :subid("17") :method :outer("30")
     .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_52
+    unless_null $P118, vivify_55
     new $P118, "Undef"
-  vivify_52:
+  vivify_55:
     $P119 = $P117."new"($P118 :named("node"))
     .lex "$past", $P119
     find_lex $P121, "$/"
     set $P122, $P121["sentence"]
-    unless_null $P122, vivify_53
+    unless_null $P122, vivify_56
     new $P122, "Undef"
-  vivify_53:
+  vivify_56:
     defined $I123, $P122
-    unless $I123, for_undef_54
+    unless $I123, for_undef_57
     iter $P120, $P122
     new $P133, 'ExceptionHandler'
     set_addr $P133, loop132_handler
     eq $P134, 66, loop132_redo
   loop132_done:
     pop_eh 
-  for_undef_54:
+  for_undef_57:
     find_lex $P135, "$/"
     find_lex $P136, "$past"
-    unless_null $P136, vivify_57
+    unless_null $P136, vivify_60
     new $P136, "Undef"
-  vivify_57:
+  vivify_60:
     $P137 = $P135."result_object"($P136)
     .return ($P137)
   control_114:
     .param pmc param_127
     .lex "$_", param_127
     find_lex $P128, "$past"
-    unless_null $P128, vivify_55
+    unless_null $P128, vivify_58
     new $P128, "Undef"
-  vivify_55:
+  vivify_58:
     find_lex $P129, "$_"
-    unless_null $P129, vivify_56
+    unless_null $P129, vivify_59
     new $P129, "Undef"
-  vivify_56:
+  vivify_59:
     $P130 = $P129."item"()
     $P131 = $P128."push"($P130)
     .return ($P131)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "sentence"  :subid("19") :method :outer("27")
+.sub "sentence"  :subid("19") :method :outer("30")
     .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_58
+    unless_null $P145, vivify_61
     new $P145, "Undef"
-  vivify_58:
+  vivify_61:
     concat $P146, $P144, $P145
     "say"($P146)
     find_lex $P147, "$/"
     find_lex $P148, "$key"
-    unless_null $P148, vivify_59
+    unless_null $P148, vivify_62
     new $P148, "Undef"
-  vivify_59:
+  vivify_62:
     find_lex $P149, "$/"
-    unless_null $P149, vivify_60
+    unless_null $P149, vivify_63
     new $P149, "Hash"
-  vivify_60:
+  vivify_63:
     set $P150, $P149[$P148]
-    unless_null $P150, vivify_61
+    unless_null $P150, vivify_64
     new $P150, "Undef"
-  vivify_61:
+  vivify_64:
     $P151 = $P150."item"()
     $P152 = $P147."result_object"($P151)
     .return ($P152)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "value"  :subid("20") :method :outer("27")
+.sub "value"  :subid("20") :method :outer("30")
     .param pmc param_157
     .param pmc param_158
     new $P156, 'ExceptionHandler'
     .lex "$key", param_158
     find_lex $P159, "$/"
     find_lex $P160, "$key"
-    unless_null $P160, vivify_62
+    unless_null $P160, vivify_65
     new $P160, "Undef"
-  vivify_62:
+  vivify_65:
     find_lex $P161, "$/"
-    unless_null $P161, vivify_63
+    unless_null $P161, vivify_66
     new $P161, "Hash"
-  vivify_63:
+  vivify_66:
     set $P162, $P161[$P160]
-    unless_null $P162, vivify_64
+    unless_null $P162, vivify_67
     new $P162, "Undef"
-  vivify_64:
+  vivify_67:
     $P163 = $P162."item"()
     $P164 = $P159."result_object"($P163)
     .return ($P164)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "immediate"  :subid("21") :method :outer("27")
+.sub "question"  :subid("21") :method :outer("30")
     .param pmc param_169
+    .param pmc param_170
     new $P168, 'ExceptionHandler'
     set_addr $P168, control_167
     $P168."handle_types"(58)
     push_eh $P168
     .lex "$/", param_169
-    new $P170, "Integer"
-    assign $P170, 1
-    .lex "$value", $P170
-    find_lex $P172, "$/"
-    set $P173, $P172["adjective"]
-    unless_null $P173, vivify_65
+    .lex "$key", param_170
+    get_hll_global $P171, ["PAST"], "Op"
+    find_lex $P172, "$key"
+    unless_null $P172, vivify_68
+    new $P172, "Undef"
+  vivify_68:
+    find_lex $P173, "$/"
+    unless_null $P173, vivify_69
     new $P173, "Undef"
-  vivify_65:
-    defined $I174, $P173
-    unless $I174, for_undef_66
-    iter $P171, $P173
-    new $P182, 'ExceptionHandler'
-    set_addr $P182, loop181_handler
-    $P182."handle_types"(64, 66, 65)
-    push_eh $P182
-  loop181_test:
-    unless $P171, loop181_done
-    shift $P175, $P171
-  loop181_redo:
-    .const 'Sub' $P177 = "22" 
-    capture_lex $P177
-    $P177($P175)
-  loop181_next:
-    goto loop181_test
-  loop181_handler:
+  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"
+  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:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P183, exception, 'type'
-    eq $P183, 64, loop181_next
-    eq $P183, 66, loop181_redo
-  loop181_done:
+    getattribute $P189, exception, 'type'
+    eq $P189, 64, loop187_next
+    eq $P189, 66, loop187_redo
+  loop187_done:
     pop_eh 
-  for_undef_66:
-    find_lex $P184, "$/"
-    get_hll_global $P185, ["PAST"], "Val"
-    find_lex $P186, "$value"
-    unless_null $P186, vivify_68
-    new $P186, "Undef"
-  vivify_68:
-    find_lex $P187, "$/"
-    unless_null $P187, vivify_69
-    new $P187, "Undef"
-  vivify_69:
-    $P188 = $P185."new"($P186 :named("value"), "Integer" :named("returns"), $P187 :named("node"))
-    $P189 = $P184."result_object"($P188)
-    .return ($P189)
+  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 $P190, exception, "payload"
-    .return ($P190)
+    getattribute $P193, exception, "payload"
+    .return ($P193)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block176"  :anon :subid("22") :outer("21")
-    .param pmc param_178
-    .lex "$_", param_178
-    find_lex $P179, "$value"
-    unless_null $P179, vivify_67
-    new $P179, "Undef"
-  vivify_67:
-    mul $P180, $P179, 2
-    store_lex "$value", $P180
-    .return ($P180)
+.sub "_block180"  :anon :subid("22") :outer("21")
+    .param pmc param_182
+    .lex "$_", param_182
+    find_lex $P183, "$res"
+    unless_null $P183, vivify_72
+    new $P183, "Undef"
+  vivify_72:
+    find_lex $P184, "$_"
+    unless_null $P184, vivify_73
+    new $P184, "Undef"
+  vivify_73:
+    $P185 = $P184."item"()
+    $P186 = $P183."push"($P185)
+    .return ($P186)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "computation"  :subid("23") :method :outer("27")
-    .param pmc param_194
-    .param pmc param_195
-    new $P193, 'ExceptionHandler'
-    set_addr $P193, control_192
-    $P193."handle_types"(58)
-    push_eh $P193
-    .lex "$/", param_194
-    .lex "$key", param_195
-    find_lex $P196, "$/"
-    find_lex $P197, "$key"
-    unless_null $P197, vivify_70
-    new $P197, "Undef"
-  vivify_70:
-    find_lex $P198, "$/"
-    unless_null $P198, vivify_71
-    new $P198, "Hash"
-  vivify_71:
-    set $P199, $P198[$P197]
-    unless_null $P199, vivify_72
-    new $P199, "Undef"
-  vivify_72:
-    $P200 = $P199."item"()
-    $P201 = $P196."result_object"($P200)
-    .return ($P201)
-  control_192:
+.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"
+  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 $P202, exception, "payload"
-    .return ($P202)
+    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"
+    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:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P218, exception, "payload"
+    .return ($P218)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "unary"  :subid("24") :method :outer("27")
+.sub "_block204"  :anon :subid("24") :outer("23")
     .param pmc param_206
-    .param pmc param_207
-    new $P205, 'ExceptionHandler'
-    set_addr $P205, control_204
-    $P205."handle_types"(58)
-    push_eh $P205
-    .lex "$/", param_206
-    .lex "$key", param_207
-    get_hll_global $P208, ["PAST"], "Op"
-    find_lex $P209, "$key"
-    unless_null $P209, vivify_73
-    new $P209, "Undef"
-  vivify_73:
-    find_lex $P210, "$/"
-    unless_null $P210, vivify_74
-    new $P210, "Undef"
-  vivify_74:
-    $P211 = $P208."new"($P209 :named("name"), "call" :named("pasttype"), $P210 :named("node"))
-    .lex "$res", $P211
-    find_lex $P212, "$res"
-    unless_null $P212, vivify_75
-    new $P212, "Undef"
-  vivify_75:
-    find_lex $P213, "$/"
-    set $P214, $P213["value"]
-    unless_null $P214, vivify_76
-    new $P214, "Undef"
-  vivify_76:
-    $P215 = $P214."item"()
-    $P212."push"($P215)
-    find_lex $P216, "$/"
-    find_lex $P217, "$res"
-    unless_null $P217, vivify_77
-    new $P217, "Undef"
+    .lex "$_", param_206
+    find_lex $P207, "$value"
+    unless_null $P207, vivify_77
+    new $P207, "Undef"
   vivify_77:
-    $P218 = $P216."result_object"($P217)
-    .return ($P218)
-  control_204:
+    mul $P208, $P207, 2
+    store_lex "$value", $P208
+    .return ($P208)
+.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:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P219, exception, "payload"
-    .return ($P219)
+    getattribute $P230, exception, "payload"
+    .return ($P230)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "binary"  :subid("25") :method :outer("27")
-    .param pmc param_223
-    .param pmc param_224
-    new $P222, 'ExceptionHandler'
-    set_addr $P222, control_221
-    $P222."handle_types"(58)
-    push_eh $P222
-    .lex "$/", param_223
-    .lex "$key", param_224
-    get_hll_global $P225, ["PAST"], "Op"
-    find_lex $P226, "$key"
-    unless_null $P226, vivify_78
-    new $P226, "Undef"
-  vivify_78:
-    find_lex $P227, "$/"
-    unless_null $P227, vivify_79
-    new $P227, "Undef"
-  vivify_79:
-    $P228 = $P225."new"($P226 :named("name"), "call" :named("pasttype"), $P227 :named("node"))
-    .lex "$res", $P228
-    find_lex $P230, "$/"
-    set $P231, $P230["value"]
-    unless_null $P231, vivify_80
-    new $P231, "Undef"
-  vivify_80:
-    defined $I232, $P231
-    unless $I232, for_undef_81
-    iter $P229, $P231
-    new $P242, 'ExceptionHandler'
-    set_addr $P242, loop241_handler
-    $P242."handle_types"(64, 66, 65)
-    push_eh $P242
-  loop241_test:
-    unless $P229, loop241_done
-    shift $P233, $P229
-  loop241_redo:
-    .const 'Sub' $P235 = "26" 
-    capture_lex $P235
-    $P235($P233)
-  loop241_next:
-    goto loop241_test
-  loop241_handler:
+.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:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P243, exception, 'type'
-    eq $P243, 64, loop241_next
-    eq $P243, 66, loop241_redo
-  loop241_done:
-    pop_eh 
-  for_undef_81:
-    find_lex $P244, "$/"
-    find_lex $P245, "$res"
-    unless_null $P245, vivify_84
-    new $P245, "Undef"
-  vivify_84:
-    $P246 = $P244."result_object"($P245)
-    .return ($P246)
-  control_221:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P247, exception, "payload"
-    .return ($P247)
+    getattribute $P242, exception, "payload"
+    .return ($P242)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block234"  :anon :subid("26") :outer("25")
-    .param pmc param_236
-    .lex "$_", param_236
-    find_lex $P237, "$res"
-    unless_null $P237, vivify_82
-    new $P237, "Undef"
-  vivify_82:
-    find_lex $P238, "$_"
-    unless_null $P238, vivify_83
-    new $P238, "Undef"
-  vivify_83:
-    $P239 = $P238."item"()
-    $P240 = $P237."push"($P239)
-    .return ($P240)
+.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"
+  vivify_88:
+    $P255 = $P254."item"()
+    $P252."push"($P255)
+    find_lex $P256, "$/"
+    find_lex $P257, "$res"
+    unless_null $P257, vivify_89
+    new $P257, "Undef"
+  vivify_89:
+    $P258 = $P256."result_object"($P257)
+    .return ($P258)
+  control_244:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P259, exception, "payload"
+    .return ($P259)
+    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:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P283, exception, 'type'
+    eq $P283, 64, loop281_next
+    eq $P283, 66, loop281_redo
+  loop281_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:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P287, exception, "payload"
+    .return ($P287)
+    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)
+.end
+