Commits

Anonymous committed 1d88f29

scene work

  • Participants
  • Parent commits 04e8bf0

Comments (0)

Files changed (10)

+syntax: glob
+*.swp
+

File .t.z.swp

Binary file modified.

File src/gen_actions.pir

 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block13" :init :load :subid("20")
+.sub "_block13" :init :load :subid("25")
+    .const 'Sub' $P173 = "23" 
+    capture_lex $P173
+    .const 'Sub' $P156 = "22" 
+    capture_lex $P156
+    .const 'Sub' $P144 = "21" 
+    capture_lex $P144
+    .const 'Sub' $P119 = "19" 
+    capture_lex $P119
     .const 'Sub' $P107 = "18" 
     capture_lex $P107
-    .const 'Sub' $P90 = "17" 
-    capture_lex $P90
-    .const 'Sub' $P78 = "16" 
-    capture_lex $P78
-    .const 'Sub' $P53 = "14" 
-    capture_lex $P53
+    .const 'Sub' $P95 = "17" 
+    capture_lex $P95
+    .const 'Sub' $P69 = "15" 
+    capture_lex $P69
     .const 'Sub' $P41 = "13" 
     capture_lex $P41
     .const 'Sub' $P15 = "11" 
         $P2 = $P0.'new_class'($P1)
       subclass_done:
         pop_eh
-    .const 'Sub' $P107 = "18" 
-    capture_lex $P107
-    .return ($P107)
+    .const 'Sub' $P173 = "23" 
+    capture_lex $P173
+    .return ($P173)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "TOP"  :subid("11") :method :outer("20")
+.sub "TOP"  :subid("11") :method :outer("25")
     .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_21
+    unless_null $P20, vivify_26
     new $P20, "Undef"
-  vivify_21:
+  vivify_26:
     $P21 = $P19."new"($P20 :named("node"))
     .lex "$past", $P21
     find_lex $P23, "$/"
-    set $P24, $P23["value"]
-    unless_null $P24, vivify_22
+    set $P24, $P23["scene"]
+    unless_null $P24, vivify_27
     new $P24, "Undef"
-  vivify_22:
+  vivify_27:
     defined $I25, $P24
-    unless $I25, for_undef_23
+    unless $I25, for_undef_28
     iter $P22, $P24
     new $P35, 'ExceptionHandler'
     set_addr $P35, loop34_handler
     eq $P36, 66, loop34_redo
   loop34_done:
     pop_eh 
-  for_undef_23:
+  for_undef_28:
     find_lex $P37, "$/"
     find_lex $P38, "$past"
-    unless_null $P38, vivify_26
+    unless_null $P38, vivify_31
     new $P38, "Undef"
-  vivify_26:
+  vivify_31:
     $P39 = $P37."result_object"($P38)
     .return ($P39)
   control_16:
     .param pmc param_29
     .lex "$_", param_29
     find_lex $P30, "$past"
-    unless_null $P30, vivify_24
+    unless_null $P30, vivify_29
     new $P30, "Undef"
-  vivify_24:
+  vivify_29:
     find_lex $P31, "$_"
-    unless_null $P31, vivify_25
+    unless_null $P31, vivify_30
     new $P31, "Undef"
-  vivify_25:
+  vivify_30:
     $P32 = $P31."item"()
     $P33 = $P30."push"($P32)
     .return ($P33)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "value"  :subid("13") :method :outer("20")
+.sub "scene"  :subid("13") :method :outer("25")
     .param pmc param_44
-    .param pmc param_45
     new $P43, 'ExceptionHandler'
     set_addr $P43, control_42
     $P43."handle_types"(58)
     push_eh $P43
     .lex "$/", param_44
-    .lex "$key", param_45
-    "say"("va")
+    get_hll_global $P45, ["PAST"], "Block"
     find_lex $P46, "$/"
-    find_lex $P47, "$key"
-    unless_null $P47, vivify_27
+    set $P47, $P46["roman"]
+    unless_null $P47, vivify_32
     new $P47, "Undef"
-  vivify_27:
+  vivify_32:
     find_lex $P48, "$/"
-    unless_null $P48, vivify_28
-    new $P48, "Hash"
-  vivify_28:
-    set $P49, $P48[$P47]
-    unless_null $P49, vivify_29
-    new $P49, "Undef"
-  vivify_29:
-    $P50 = $P49."item"()
-    $P51 = $P46."result_object"($P50)
-    .return ($P51)
+    unless_null $P48, vivify_33
+    new $P48, "Undef"
+  vivify_33:
+    $P49 = $P45."new"($P47 :named("name"), $P48 :named("node"))
+    .lex "$past", $P49
+    find_lex $P51, "$/"
+    set $P52, $P51["line"]
+    unless_null $P52, vivify_34
+    new $P52, "Undef"
+  vivify_34:
+    defined $I53, $P52
+    unless $I53, for_undef_35
+    iter $P50, $P52
+    new $P63, 'ExceptionHandler'
+    set_addr $P63, loop62_handler
+    $P63."handle_types"(64, 66, 65)
+    push_eh $P63
+  loop62_test:
+    unless $P50, loop62_done
+    shift $P54, $P50
+  loop62_redo:
+    .const 'Sub' $P56 = "14" 
+    capture_lex $P56
+    $P56($P54)
+  loop62_next:
+    goto loop62_test
+  loop62_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P64, exception, 'type'
+    eq $P64, 64, loop62_next
+    eq $P64, 66, loop62_redo
+  loop62_done:
+    pop_eh 
+  for_undef_35:
+    find_lex $P65, "$/"
+    find_lex $P66, "$past"
+    unless_null $P66, vivify_38
+    new $P66, "Undef"
+  vivify_38:
+    $P67 = $P65."result_object"($P66)
+    .return ($P67)
   control_42:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P52, exception, "payload"
-    .return ($P52)
+    getattribute $P68, exception, "payload"
+    .return ($P68)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "immediate"  :subid("14") :method :outer("20")
-    .param pmc param_56
-    new $P55, 'ExceptionHandler'
-    set_addr $P55, control_54
-    $P55."handle_types"(58)
-    push_eh $P55
-    .lex "$/", param_56
-    "say"("imm")
-    new $P57, "Integer"
-    assign $P57, 1
-    .lex "$value", $P57
-    find_lex $P59, "$/"
-    set $P60, $P59["adjective"]
-    unless_null $P60, vivify_30
-    new $P60, "Undef"
-  vivify_30:
-    defined $I61, $P60
-    unless $I61, for_undef_31
-    iter $P58, $P60
-    new $P69, 'ExceptionHandler'
-    set_addr $P69, loop68_handler
-    $P69."handle_types"(64, 66, 65)
-    push_eh $P69
-  loop68_test:
-    unless $P58, loop68_done
-    shift $P62, $P58
-  loop68_redo:
-    .const 'Sub' $P64 = "15" 
-    capture_lex $P64
-    $P64($P62)
-  loop68_next:
-    goto loop68_test
-  loop68_handler:
+.sub "_block55"  :anon :subid("14") :outer("13")
+    .param pmc param_57
+    .lex "$_", param_57
+    find_lex $P58, "$past"
+    unless_null $P58, vivify_36
+    new $P58, "Undef"
+  vivify_36:
+    find_lex $P59, "$_"
+    unless_null $P59, vivify_37
+    new $P59, "Undef"
+  vivify_37:
+    $P60 = $P59."item"()
+    $P61 = $P58."push"($P60)
+    .return ($P61)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "line"  :subid("15") :method :outer("25")
+    .param pmc param_72
+    new $P71, 'ExceptionHandler'
+    set_addr $P71, control_70
+    $P71."handle_types"(58)
+    push_eh $P71
+    .lex "$/", param_72
+    get_hll_global $P73, ["PAST"], "Stmts"
+    find_lex $P74, "$/"
+    unless_null $P74, vivify_39
+    new $P74, "Undef"
+  vivify_39:
+    $P75 = $P73."new"($P74 :named("node"))
+    .lex "$past", $P75
+    find_lex $P77, "$/"
+    set $P78, $P77["sentence"]
+    unless_null $P78, vivify_40
+    new $P78, "Undef"
+  vivify_40:
+    defined $I79, $P78
+    unless $I79, for_undef_41
+    iter $P76, $P78
+    new $P89, 'ExceptionHandler'
+    set_addr $P89, loop88_handler
+    $P89."handle_types"(64, 66, 65)
+    push_eh $P89
+  loop88_test:
+    unless $P76, loop88_done
+    shift $P80, $P76
+  loop88_redo:
+    .const 'Sub' $P82 = "16" 
+    capture_lex $P82
+    $P82($P80)
+  loop88_next:
+    goto loop88_test
+  loop88_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P70, exception, 'type'
-    eq $P70, 64, loop68_next
-    eq $P70, 66, loop68_redo
-  loop68_done:
+    getattribute $P90, exception, 'type'
+    eq $P90, 64, loop88_next
+    eq $P90, 66, loop88_redo
+  loop88_done:
     pop_eh 
-  for_undef_31:
-    find_lex $P71, "$/"
-    get_hll_global $P72, ["PAST"], "Val"
-    find_lex $P73, "$value"
-    unless_null $P73, vivify_33
-    new $P73, "Undef"
-  vivify_33:
-    find_lex $P74, "$/"
-    unless_null $P74, vivify_34
-    new $P74, "Undef"
-  vivify_34:
-    $P75 = $P72."new"($P73 :named("value"), "Integer" :named("returns"), $P74 :named("node"))
-    $P76 = $P71."result_object"($P75)
-    .return ($P76)
-  control_54:
+  for_undef_41:
+    find_lex $P91, "$/"
+    find_lex $P92, "$past"
+    unless_null $P92, vivify_44
+    new $P92, "Undef"
+  vivify_44:
+    $P93 = $P91."result_object"($P92)
+    .return ($P93)
+  control_70:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P77, exception, "payload"
-    .return ($P77)
+    getattribute $P94, exception, "payload"
+    .return ($P94)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block63"  :anon :subid("15") :outer("14")
-    .param pmc param_65
-    .lex "$_", param_65
-    find_lex $P66, "$value"
-    unless_null $P66, vivify_32
-    new $P66, "Undef"
-  vivify_32:
-    mul $P67, $P66, 2
-    store_lex "$value", $P67
-    .return ($P67)
+.sub "_block81"  :anon :subid("16") :outer("15")
+    .param pmc param_83
+    .lex "$_", param_83
+    find_lex $P84, "$past"
+    unless_null $P84, vivify_42
+    new $P84, "Undef"
+  vivify_42:
+    find_lex $P85, "$_"
+    unless_null $P85, vivify_43
+    new $P85, "Undef"
+  vivify_43:
+    $P86 = $P85."item"()
+    $P87 = $P84."push"($P86)
+    .return ($P87)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "computation"  :subid("16") :method :outer("20")
-    .param pmc param_81
-    .param pmc param_82
-    new $P80, 'ExceptionHandler'
-    set_addr $P80, control_79
-    $P80."handle_types"(58)
-    push_eh $P80
-    .lex "$/", param_81
-    .lex "$key", param_82
-    find_lex $P83, "$/"
-    find_lex $P84, "$key"
-    unless_null $P84, vivify_35
-    new $P84, "Undef"
-  vivify_35:
-    find_lex $P85, "$/"
-    unless_null $P85, vivify_36
-    new $P85, "Hash"
-  vivify_36:
-    set $P86, $P85[$P84]
-    unless_null $P86, vivify_37
-    new $P86, "Undef"
-  vivify_37:
-    $P87 = $P86."item"()
-    $P88 = $P83."result_object"($P87)
-    .return ($P88)
-  control_79:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P89, exception, "payload"
-    .return ($P89)
-    rethrow exception
-.end
-
-
-.namespace ["z2";"Grammar";"Actions"]
-.sub "unary"  :subid("17") :method :outer("20")
-    .param pmc param_93
-    .param pmc param_94
-    new $P92, 'ExceptionHandler'
-    set_addr $P92, control_91
-    $P92."handle_types"(58)
-    push_eh $P92
-    .lex "$/", param_93
-    .lex "$key", param_94
-    get_hll_global $P95, ["PAST"], "Op"
-    find_lex $P96, "$key"
-    unless_null $P96, vivify_38
-    new $P96, "Undef"
-  vivify_38:
-    find_lex $P97, "$/"
-    unless_null $P97, vivify_39
-    new $P97, "Undef"
-  vivify_39:
-    $P98 = $P95."new"($P96 :named("name"), "call" :named("pasttype"), $P97 :named("node"))
-    .lex "$res", $P98
-    find_lex $P99, "$res"
-    unless_null $P99, vivify_40
-    new $P99, "Undef"
-  vivify_40:
+.sub "sentence"  :subid("17") :method :outer("25")
+    .param pmc param_98
+    .param pmc param_99
+    new $P97, 'ExceptionHandler'
+    set_addr $P97, control_96
+    $P97."handle_types"(58)
+    push_eh $P97
+    .lex "$/", param_98
+    .lex "$key", param_99
     find_lex $P100, "$/"
-    set $P101, $P100["value"]
-    unless_null $P101, vivify_41
+    find_lex $P101, "$key"
+    unless_null $P101, vivify_45
     new $P101, "Undef"
-  vivify_41:
-    $P102 = $P101."item"()
-    $P99."push"($P102)
-    find_lex $P103, "$/"
-    find_lex $P104, "$res"
-    unless_null $P104, vivify_42
-    new $P104, "Undef"
-  vivify_42:
-    $P105 = $P103."result_object"($P104)
+  vivify_45:
+    find_lex $P102, "$/"
+    unless_null $P102, vivify_46
+    new $P102, "Hash"
+  vivify_46:
+    set $P103, $P102[$P101]
+    unless_null $P103, vivify_47
+    new $P103, "Undef"
+  vivify_47:
+    $P104 = $P103."item"()
+    $P105 = $P100."result_object"($P104)
     .return ($P105)
-  control_91:
+  control_96:
     .local pmc exception 
     .get_results (exception) 
     getattribute $P106, exception, "payload"
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "binary"  :subid("18") :method :outer("20")
+.sub "value"  :subid("18") :method :outer("25")
     .param pmc param_110
     .param pmc param_111
     new $P109, 'ExceptionHandler'
     push_eh $P109
     .lex "$/", param_110
     .lex "$key", param_111
-    get_hll_global $P112, ["PAST"], "Op"
+    find_lex $P112, "$/"
     find_lex $P113, "$key"
-    unless_null $P113, vivify_43
+    unless_null $P113, vivify_48
     new $P113, "Undef"
-  vivify_43:
+  vivify_48:
     find_lex $P114, "$/"
-    unless_null $P114, vivify_44
-    new $P114, "Undef"
-  vivify_44:
-    $P115 = $P112."new"($P113 :named("name"), "call" :named("pasttype"), $P114 :named("node"))
-    .lex "$res", $P115
-    find_lex $P117, "$/"
-    set $P118, $P117["value"]
-    unless_null $P118, vivify_45
-    new $P118, "Undef"
-  vivify_45:
-    defined $I119, $P118
-    unless $I119, for_undef_46
-    iter $P116, $P118
-    new $P129, 'ExceptionHandler'
-    set_addr $P129, loop128_handler
-    $P129."handle_types"(64, 66, 65)
-    push_eh $P129
-  loop128_test:
-    unless $P116, loop128_done
-    shift $P120, $P116
-  loop128_redo:
-    .const 'Sub' $P122 = "19" 
-    capture_lex $P122
-    $P122($P120)
-  loop128_next:
-    goto loop128_test
-  loop128_handler:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P130, exception, 'type'
-    eq $P130, 64, loop128_next
-    eq $P130, 66, loop128_redo
-  loop128_done:
-    pop_eh 
-  for_undef_46:
-    find_lex $P131, "$/"
-    find_lex $P132, "$res"
-    unless_null $P132, vivify_49
-    new $P132, "Undef"
+    unless_null $P114, vivify_49
+    new $P114, "Hash"
   vivify_49:
-    $P133 = $P131."result_object"($P132)
-    .return ($P133)
+    set $P115, $P114[$P113]
+    unless_null $P115, vivify_50
+    new $P115, "Undef"
+  vivify_50:
+    $P116 = $P115."item"()
+    $P117 = $P112."result_object"($P116)
+    .return ($P117)
   control_108:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P134, exception, "payload"
-    .return ($P134)
+    getattribute $P118, exception, "payload"
+    .return ($P118)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block121"  :anon :subid("19") :outer("18")
-    .param pmc param_123
-    .lex "$_", param_123
-    find_lex $P124, "$res"
-    unless_null $P124, vivify_47
-    new $P124, "Undef"
-  vivify_47:
-    find_lex $P125, "$_"
-    unless_null $P125, vivify_48
-    new $P125, "Undef"
-  vivify_48:
-    $P126 = $P125."item"()
-    $P127 = $P124."push"($P126)
-    .return ($P127)
+.sub "immediate"  :subid("19") :method :outer("25")
+    .param pmc param_122
+    new $P121, 'ExceptionHandler'
+    set_addr $P121, control_120
+    $P121."handle_types"(58)
+    push_eh $P121
+    .lex "$/", param_122
+    new $P123, "Integer"
+    assign $P123, 1
+    .lex "$value", $P123
+    find_lex $P125, "$/"
+    set $P126, $P125["adjective"]
+    unless_null $P126, vivify_51
+    new $P126, "Undef"
+  vivify_51:
+    defined $I127, $P126
+    unless $I127, for_undef_52
+    iter $P124, $P126
+    new $P135, 'ExceptionHandler'
+    set_addr $P135, loop134_handler
+    $P135."handle_types"(64, 66, 65)
+    push_eh $P135
+  loop134_test:
+    unless $P124, loop134_done
+    shift $P128, $P124
+  loop134_redo:
+    .const 'Sub' $P130 = "20" 
+    capture_lex $P130
+    $P130($P128)
+  loop134_next:
+    goto loop134_test
+  loop134_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P136, exception, 'type'
+    eq $P136, 64, loop134_next
+    eq $P136, 66, loop134_redo
+  loop134_done:
+    pop_eh 
+  for_undef_52:
+    find_lex $P137, "$/"
+    get_hll_global $P138, ["PAST"], "Val"
+    find_lex $P139, "$value"
+    unless_null $P139, vivify_54
+    new $P139, "Undef"
+  vivify_54:
+    find_lex $P140, "$/"
+    unless_null $P140, vivify_55
+    new $P140, "Undef"
+  vivify_55:
+    $P141 = $P138."new"($P139 :named("value"), "Integer" :named("returns"), $P140 :named("node"))
+    $P142 = $P137."result_object"($P141)
+    .return ($P142)
+  control_120:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P143, exception, "payload"
+    .return ($P143)
+    rethrow exception
 .end
 
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "_block129"  :anon :subid("20") :outer("19")
+    .param pmc param_131
+    .lex "$_", param_131
+    find_lex $P132, "$value"
+    unless_null $P132, vivify_53
+    new $P132, "Undef"
+  vivify_53:
+    mul $P133, $P132, 2
+    store_lex "$value", $P133
+    .return ($P133)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "computation"  :subid("21") :method :outer("25")
+    .param pmc param_147
+    .param pmc param_148
+    new $P146, 'ExceptionHandler'
+    set_addr $P146, control_145
+    $P146."handle_types"(58)
+    push_eh $P146
+    .lex "$/", param_147
+    .lex "$key", param_148
+    find_lex $P149, "$/"
+    find_lex $P150, "$key"
+    unless_null $P150, vivify_56
+    new $P150, "Undef"
+  vivify_56:
+    find_lex $P151, "$/"
+    unless_null $P151, vivify_57
+    new $P151, "Hash"
+  vivify_57:
+    set $P152, $P151[$P150]
+    unless_null $P152, vivify_58
+    new $P152, "Undef"
+  vivify_58:
+    $P153 = $P152."item"()
+    $P154 = $P149."result_object"($P153)
+    .return ($P154)
+  control_145:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P155, exception, "payload"
+    .return ($P155)
+    rethrow exception
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "unary"  :subid("22") :method :outer("25")
+    .param pmc param_159
+    .param pmc param_160
+    new $P158, 'ExceptionHandler'
+    set_addr $P158, control_157
+    $P158."handle_types"(58)
+    push_eh $P158
+    .lex "$/", param_159
+    .lex "$key", param_160
+    get_hll_global $P161, ["PAST"], "Op"
+    find_lex $P162, "$key"
+    unless_null $P162, vivify_59
+    new $P162, "Undef"
+  vivify_59:
+    find_lex $P163, "$/"
+    unless_null $P163, vivify_60
+    new $P163, "Undef"
+  vivify_60:
+    $P164 = $P161."new"($P162 :named("name"), "call" :named("pasttype"), $P163 :named("node"))
+    .lex "$res", $P164
+    find_lex $P165, "$res"
+    unless_null $P165, vivify_61
+    new $P165, "Undef"
+  vivify_61:
+    find_lex $P166, "$/"
+    set $P167, $P166["value"]
+    unless_null $P167, vivify_62
+    new $P167, "Undef"
+  vivify_62:
+    $P168 = $P167."item"()
+    $P165."push"($P168)
+    find_lex $P169, "$/"
+    find_lex $P170, "$res"
+    unless_null $P170, vivify_63
+    new $P170, "Undef"
+  vivify_63:
+    $P171 = $P169."result_object"($P170)
+    .return ($P171)
+  control_157:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P172, exception, "payload"
+    .return ($P172)
+    rethrow exception
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "binary"  :subid("23") :method :outer("25")
+    .param pmc param_176
+    .param pmc param_177
+    new $P175, 'ExceptionHandler'
+    set_addr $P175, control_174
+    $P175."handle_types"(58)
+    push_eh $P175
+    .lex "$/", param_176
+    .lex "$key", param_177
+    get_hll_global $P178, ["PAST"], "Op"
+    find_lex $P179, "$key"
+    unless_null $P179, vivify_64
+    new $P179, "Undef"
+  vivify_64:
+    find_lex $P180, "$/"
+    unless_null $P180, vivify_65
+    new $P180, "Undef"
+  vivify_65:
+    $P181 = $P178."new"($P179 :named("name"), "call" :named("pasttype"), $P180 :named("node"))
+    .lex "$res", $P181
+    find_lex $P183, "$/"
+    set $P184, $P183["value"]
+    unless_null $P184, vivify_66
+    new $P184, "Undef"
+  vivify_66:
+    defined $I185, $P184
+    unless $I185, for_undef_67
+    iter $P182, $P184
+    new $P195, 'ExceptionHandler'
+    set_addr $P195, loop194_handler
+    $P195."handle_types"(64, 66, 65)
+    push_eh $P195
+  loop194_test:
+    unless $P182, loop194_done
+    shift $P186, $P182
+  loop194_redo:
+    .const 'Sub' $P188 = "24" 
+    capture_lex $P188
+    $P188($P186)
+  loop194_next:
+    goto loop194_test
+  loop194_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P196, exception, 'type'
+    eq $P196, 64, loop194_next
+    eq $P196, 66, loop194_redo
+  loop194_done:
+    pop_eh 
+  for_undef_67:
+    find_lex $P197, "$/"
+    find_lex $P198, "$res"
+    unless_null $P198, vivify_70
+    new $P198, "Undef"
+  vivify_70:
+    $P199 = $P197."result_object"($P198)
+    .return ($P199)
+  control_174:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P200, exception, "payload"
+    .return ($P200)
+    rethrow exception
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "_block187"  :anon :subid("24") :outer("23")
+    .param pmc param_189
+    .lex "$_", param_189
+    find_lex $P190, "$res"
+    unless_null $P190, vivify_68
+    new $P190, "Undef"
+  vivify_68:
+    find_lex $P191, "$_"
+    unless_null $P191, vivify_69
+    new $P191, "Undef"
+  vivify_69:
+    $P192 = $P191."item"()
+    $P193 = $P190."push"($P192)
+    .return ($P193)
+.end
+