Commits

Anonymous committed 27d223c

unless and if work and branch as expected (scene wise)

  • Participants
  • Parent commits 2c73989

Comments (0)

Files changed (7)

File src/builtins/say.pir

     print "add\n"
     .return ()
 .end
+.namespace []
+.sub 'better'
+    .param int a
+    .param int b
+    new $P0, 'Integer'
+    print "better("
+    print a
+    print ","
+    print b
+    $I0 = a > b
+    set $P0, $I0
+    print ") -> "
+    set_global 'the_condition', $P0
+    print $P0
+    print "\n"
+    .return ($P0)
+.end
 # Local Variables:
 #   mode: pir
 #   fill-column: 100

File src/gen_actions.pir

 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "_block13" :init :load :subid("32")
-    .const 'Sub' $P280 = "30" 
-    capture_lex $P280
-    .const 'Sub' $P263 = "29" 
-    capture_lex $P263
-    .const 'Sub' $P251 = "28" 
-    capture_lex $P251
-    .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" 
-    capture_lex $P139
-    .const 'Sub' $P113 = "17" 
-    capture_lex $P113
-    .const 'Sub' $P98 = "16" 
-    capture_lex $P98
-    .const 'Sub' $P79 = "15" 
-    capture_lex $P79
-    .const 'Sub' $P41 = "13" 
-    capture_lex $P41
+    .const 'Sub' $P298 = "30" 
+    capture_lex $P298
+    .const 'Sub' $P281 = "29" 
+    capture_lex $P281
+    .const 'Sub' $P269 = "28" 
+    capture_lex $P269
+    .const 'Sub' $P250 = "27" 
+    capture_lex $P250
+    .const 'Sub' $P225 = "25" 
+    capture_lex $P225
+    .const 'Sub' $P184 = "23" 
+    capture_lex $P184
+    .const 'Sub' $P172 = "22" 
+    capture_lex $P172
+    .const 'Sub' $P159 = "20" 
+    capture_lex $P159
+    .const 'Sub' $P144 = "19" 
+    capture_lex $P144
+    .const 'Sub' $P118 = "17" 
+    capture_lex $P118
+    .const 'Sub' $P103 = "16" 
+    capture_lex $P103
+    .const 'Sub' $P84 = "15" 
+    capture_lex $P84
+    .const 'Sub' $P46 = "13" 
+    capture_lex $P46
     .const 'Sub' $P15 = "11" 
     capture_lex $P15
         $P0 = get_hll_global 'P6metaclass'
         $P2 = $P0.'new_class'($P1)
       subclass_done:
         pop_eh
-    .const 'Sub' $P280 = "30" 
-    capture_lex $P280
-    .return ($P280)
+    .const 'Sub' $P298 = "30" 
+    capture_lex $P298
+    .return ($P298)
 .end
 
 
   vivify_33:
     $P21 = $P19."new"($P20 :named("node"))
     .lex "$past", $P21
+    get_hll_global $P22, ["PAST"], "Var"
     find_lex $P23, "$/"
-    set $P24, $P23["scene"]
-    unless_null $P24, vivify_34
-    new $P24, "Undef"
+    unless_null $P23, vivify_34
+    new $P23, "Undef"
   vivify_34:
-    defined $I25, $P24
-    unless $I25, for_undef_35
-    iter $P22, $P24
-    new $P35, 'ExceptionHandler'
-    set_addr $P35, loop34_handler
-    $P35."handle_types"(64, 66, 65)
-    push_eh $P35
-  loop34_test:
-    unless $P22, loop34_done
-    shift $P26, $P22
-  loop34_redo:
-    .const 'Sub' $P28 = "12" 
-    capture_lex $P28
-    $P28($P26)
-  loop34_next:
-    goto loop34_test
-  loop34_handler:
+    $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_35
+    new $P25, "Undef"
+  vivify_35:
+    find_lex $P26, "$tc"
+    unless_null $P26, vivify_36
+    new $P26, "Undef"
+  vivify_36:
+    $P25."push"($P26)
+    find_lex $P28, "$/"
+    set $P29, $P28["scene"]
+    unless_null $P29, vivify_37
+    new $P29, "Undef"
+  vivify_37:
+    defined $I30, $P29
+    unless $I30, for_undef_38
+    iter $P27, $P29
+    new $P40, 'ExceptionHandler'
+    set_addr $P40, loop39_handler
+    $P40."handle_types"(64, 66, 65)
+    push_eh $P40
+  loop39_test:
+    unless $P27, loop39_done
+    shift $P31, $P27
+  loop39_redo:
+    .const 'Sub' $P33 = "12" 
+    capture_lex $P33
+    $P33($P31)
+  loop39_next:
+    goto loop39_test
+  loop39_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P36, exception, 'type'
-    eq $P36, 64, loop34_next
-    eq $P36, 66, loop34_redo
-  loop34_done:
+    getattribute $P41, exception, 'type'
+    eq $P41, 64, loop39_next
+    eq $P41, 66, loop39_redo
+  loop39_done:
     pop_eh 
-  for_undef_35:
-    find_lex $P37, "$/"
-    find_lex $P38, "$past"
-    unless_null $P38, vivify_38
-    new $P38, "Undef"
-  vivify_38:
-    $P39 = $P37."result_object"($P38)
-    .return ($P39)
+  for_undef_38:
+    find_lex $P42, "$/"
+    find_lex $P43, "$past"
+    unless_null $P43, vivify_41
+    new $P43, "Undef"
+  vivify_41:
+    $P44 = $P42."result_object"($P43)
+    .return ($P44)
   control_16:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P40, exception, "payload"
-    .return ($P40)
+    getattribute $P45, exception, "payload"
+    .return ($P45)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block27"  :anon :subid("12") :outer("11")
-    .param pmc param_29
-    .lex "$_", param_29
-    find_lex $P30, "$past"
-    unless_null $P30, vivify_36
-    new $P30, "Undef"
-  vivify_36:
-    find_lex $P31, "$_"
-    unless_null $P31, vivify_37
-    new $P31, "Undef"
-  vivify_37:
-    $P32 = $P31."item"()
-    $P33 = $P30."push"($P32)
-    .return ($P33)
+.sub "_block32"  :anon :subid("12") :outer("11")
+    .param pmc param_34
+    .lex "$_", param_34
+    find_lex $P35, "$past"
+    unless_null $P35, vivify_39
+    new $P35, "Undef"
+  vivify_39:
+    find_lex $P36, "$_"
+    unless_null $P36, vivify_40
+    new $P36, "Undef"
+  vivify_40:
+    $P37 = $P36."item"()
+    $P38 = $P35."push"($P37)
+    .return ($P38)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "scene"  :subid("13") :method :outer("32")
-    .param pmc param_44
-    new $P43, 'ExceptionHandler'
-    set_addr $P43, control_42
-    $P43."handle_types"(58)
-    push_eh $P43
-    .lex "$/", param_44
-    get_hll_global $P45, ["PAST"], "Stmts"
-    find_lex $P46, "$/"
-    set $P47, $P46["roman"]
-    unless_null $P47, vivify_39
-    new $P47, "Undef"
-  vivify_39:
-    find_lex $P48, "$/"
-    unless_null $P48, vivify_40
-    new $P48, "Undef"
-  vivify_40:
-    $P49 = $P45."new"($P47 :named("name"), $P48 :named("node"))
-    .lex "$past", $P49
-    get_hll_global $P50, ["PAST"], "Op"
-    new $P51, "String"
-    assign $P51, ""
-    find_lex $P52, "$/"
-    set $P53, $P52["roman"]
-    unless_null $P53, vivify_41
+    .param pmc param_49
+    new $P48, 'ExceptionHandler'
+    set_addr $P48, control_47
+    $P48."handle_types"(58)
+    push_eh $P48
+    .lex "$/", param_49
+    get_hll_global $P50, ["PAST"], "Stmts"
+    find_lex $P51, "$/"
+    set $P52, $P51["roman"]
+    unless_null $P52, vivify_42
+    new $P52, "Undef"
+  vivify_42:
+    find_lex $P53, "$/"
+    unless_null $P53, vivify_43
     new $P53, "Undef"
-  vivify_41:
-    concat $P54, $P51, $P53
-    concat $P55, $P54, ":"
-    find_lex $P56, "$/"
-    unless_null $P56, vivify_42
-    new $P56, "Undef"
-  vivify_42:
-    $P57 = $P50."new"($P55 :named("inline"), $P56 :named("node"))
-    .lex "$lbl", $P57
-    find_lex $P58, "$past"
-    unless_null $P58, vivify_43
+  vivify_43:
+    $P54 = $P50."new"($P52 :named("name"), $P53 :named("node"))
+    .lex "$past", $P54
+    get_hll_global $P55, ["PAST"], "Op"
+    new $P56, "String"
+    assign $P56, ""
+    find_lex $P57, "$/"
+    set $P58, $P57["roman"]
+    unless_null $P58, vivify_44
     new $P58, "Undef"
-  vivify_43:
-    find_lex $P59, "$lbl"
-    unless_null $P59, vivify_44
-    new $P59, "Undef"
   vivify_44:
-    $P58."push"($P59)
+    concat $P59, $P56, $P58
+    concat $P60, $P59, ":"
     find_lex $P61, "$/"
-    set $P62, $P61["line"]
-    unless_null $P62, vivify_45
-    new $P62, "Undef"
+    unless_null $P61, vivify_45
+    new $P61, "Undef"
   vivify_45:
-    defined $I63, $P62
-    unless $I63, for_undef_46
-    iter $P60, $P62
-    new $P73, 'ExceptionHandler'
-    set_addr $P73, loop72_handler
-    $P73."handle_types"(64, 66, 65)
-    push_eh $P73
-  loop72_test:
-    unless $P60, loop72_done
-    shift $P64, $P60
-  loop72_redo:
-    .const 'Sub' $P66 = "14" 
-    capture_lex $P66
-    $P66($P64)
-  loop72_next:
-    goto loop72_test
-  loop72_handler:
+    $P62 = $P55."new"($P60 :named("inline"), $P61 :named("node"))
+    .lex "$lbl", $P62
+    find_lex $P63, "$past"
+    unless_null $P63, vivify_46
+    new $P63, "Undef"
+  vivify_46:
+    find_lex $P64, "$lbl"
+    unless_null $P64, vivify_47
+    new $P64, "Undef"
+  vivify_47:
+    $P63."push"($P64)
+    find_lex $P66, "$/"
+    set $P67, $P66["line"]
+    unless_null $P67, vivify_48
+    new $P67, "Undef"
+  vivify_48:
+    defined $I68, $P67
+    unless $I68, for_undef_49
+    iter $P65, $P67
+    new $P78, 'ExceptionHandler'
+    set_addr $P78, loop77_handler
+    $P78."handle_types"(64, 66, 65)
+    push_eh $P78
+  loop77_test:
+    unless $P65, loop77_done
+    shift $P69, $P65
+  loop77_redo:
+    .const 'Sub' $P71 = "14" 
+    capture_lex $P71
+    $P71($P69)
+  loop77_next:
+    goto loop77_test
+  loop77_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P74, exception, 'type'
-    eq $P74, 64, loop72_next
-    eq $P74, 66, loop72_redo
-  loop72_done:
+    getattribute $P79, exception, 'type'
+    eq $P79, 64, loop77_next
+    eq $P79, 66, loop77_redo
+  loop77_done:
     pop_eh 
-  for_undef_46:
-    find_lex $P75, "$/"
-    find_lex $P76, "$past"
-    unless_null $P76, vivify_49
-    new $P76, "Undef"
-  vivify_49:
-    $P77 = $P75."result_object"($P76)
-    .return ($P77)
-  control_42:
+  for_undef_49:
+    find_lex $P80, "$/"
+    find_lex $P81, "$past"
+    unless_null $P81, vivify_52
+    new $P81, "Undef"
+  vivify_52:
+    $P82 = $P80."result_object"($P81)
+    .return ($P82)
+  control_47:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P78, exception, "payload"
-    .return ($P78)
+    getattribute $P83, exception, "payload"
+    .return ($P83)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block65"  :anon :subid("14") :outer("13")
-    .param pmc param_67
-    .lex "$_", param_67
-    find_lex $P68, "$past"
-    unless_null $P68, vivify_47
-    new $P68, "Undef"
-  vivify_47:
-    find_lex $P69, "$_"
-    unless_null $P69, vivify_48
-    new $P69, "Undef"
-  vivify_48:
-    $P70 = $P69."item"()
-    $P71 = $P68."push"($P70)
-    .return ($P71)
+.sub "_block70"  :anon :subid("14") :outer("13")
+    .param pmc param_72
+    .lex "$_", param_72
+    find_lex $P73, "$past"
+    unless_null $P73, vivify_50
+    new $P73, "Undef"
+  vivify_50:
+    find_lex $P74, "$_"
+    unless_null $P74, vivify_51
+    new $P74, "Undef"
+  vivify_51:
+    $P75 = $P74."item"()
+    $P76 = $P73."push"($P75)
+    .return ($P76)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "branch"  :subid("15") :method :outer("32")
-    .param pmc param_82
-    new $P81, 'ExceptionHandler'
-    set_addr $P81, control_80
-    $P81."handle_types"(58)
-    push_eh $P81
-    .lex "$/", param_82
-    new $P83, "String"
-    assign $P83, "branch:"
-    find_lex $P84, "$/"
-    set $P85, $P84["roman"]
-    unless_null $P85, vivify_50
-    new $P85, "Undef"
-  vivify_50:
-    concat $P86, $P83, $P85
-    "dbg"($P86)
-    get_hll_global $P87, ["PAST"], "Op"
+    .param pmc param_87
+    new $P86, 'ExceptionHandler'
+    set_addr $P86, control_85
+    $P86."handle_types"(58)
+    push_eh $P86
+    .lex "$/", param_87
     new $P88, "String"
-    assign $P88, "goto "
+    assign $P88, "branch:"
     find_lex $P89, "$/"
     set $P90, $P89["roman"]
-    unless_null $P90, vivify_51
+    unless_null $P90, vivify_53
     new $P90, "Undef"
-  vivify_51:
+  vivify_53:
     concat $P91, $P88, $P90
-    find_lex $P92, "$/"
-    unless_null $P92, vivify_52
-    new $P92, "Undef"
-  vivify_52:
-    $P93 = $P87."new"($P91 :named("inline"), $P92 :named("node"))
-    .lex "$res", $P93
+    "dbg"($P91)
+    get_hll_global $P92, ["PAST"], "Op"
+    new $P93, "String"
+    assign $P93, "goto "
     find_lex $P94, "$/"
-    find_lex $P95, "$res"
-    unless_null $P95, vivify_53
+    set $P95, $P94["roman"]
+    unless_null $P95, vivify_54
     new $P95, "Undef"
-  vivify_53:
-    $P96 = $P94."result_object"($P95)
-    .return ($P96)
-  control_80:
+  vivify_54:
+    concat $P96, $P93, $P95
+    find_lex $P97, "$/"
+    unless_null $P97, vivify_55
+    new $P97, "Undef"
+  vivify_55:
+    $P98 = $P92."new"($P96 :named("inline"), $P97 :named("node"))
+    .lex "$res", $P98
+    find_lex $P99, "$/"
+    find_lex $P100, "$res"
+    unless_null $P100, vivify_56
+    new $P100, "Undef"
+  vivify_56:
+    $P101 = $P99."result_object"($P100)
+    .return ($P101)
+  control_85:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P97, exception, "payload"
-    .return ($P97)
+    getattribute $P102, exception, "payload"
+    .return ($P102)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "io"  :subid("16") :method :outer("32")
-    .param pmc param_101
-    .param pmc param_102
-    new $P100, 'ExceptionHandler'
-    set_addr $P100, control_99
-    $P100."handle_types"(58)
-    push_eh $P100
-    .lex "$/", param_101
-    .lex "$key", param_102
-    new $P103, "String"
-    assign $P103, "io:"
-    find_lex $P104, "$key"
-    unless_null $P104, vivify_54
-    new $P104, "Undef"
-  vivify_54:
-    concat $P105, $P103, $P104
-    "dbg"($P105)
-    get_hll_global $P106, ["PAST"], "Op"
-    find_lex $P107, "$/"
-    unless_null $P107, vivify_55
-    new $P107, "Undef"
-  vivify_55:
-    $P108 = $P106."new"("say2" :named("name"), "call" :named("pasttype"), $P107 :named("node"))
-    .lex "$res", $P108
+    .param pmc param_106
+    .param pmc param_107
+    new $P105, 'ExceptionHandler'
+    set_addr $P105, control_104
+    $P105."handle_types"(58)
+    push_eh $P105
+    .lex "$/", param_106
+    .lex "$key", param_107
+    new $P108, "String"
+    assign $P108, "io:"
+    find_lex $P109, "$key"
+    unless_null $P109, vivify_57
+    new $P109, "Undef"
+  vivify_57:
+    concat $P110, $P108, $P109
+    "dbg"($P110)
+    get_hll_global $P111, ["PAST"], "Op"
+    find_lex $P112, "$/"
+    unless_null $P112, vivify_58
+    new $P112, "Undef"
+  vivify_58:
+    $P113 = $P111."new"("say2" :named("name"), "call" :named("pasttype"), $P112 :named("node"))
+    .lex "$res", $P113
     "dbg"("ok")
-    find_lex $P109, "$/"
-    find_lex $P110, "$res"
-    unless_null $P110, vivify_56
-    new $P110, "Undef"
-  vivify_56:
-    $P111 = $P109."result_object"($P110)
-    .return ($P111)
-  control_99:
+    find_lex $P114, "$/"
+    find_lex $P115, "$res"
+    unless_null $P115, vivify_59
+    new $P115, "Undef"
+  vivify_59:
+    $P116 = $P114."result_object"($P115)
+    .return ($P116)
+  control_104:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P112, exception, "payload"
-    .return ($P112)
+    getattribute $P117, exception, "payload"
+    .return ($P117)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "line"  :subid("17") :method :outer("32")
-    .param pmc param_116
-    new $P115, 'ExceptionHandler'
-    set_addr $P115, control_114
-    $P115."handle_types"(58)
-    push_eh $P115
-    .lex "$/", param_116
-    get_hll_global $P117, ["PAST"], "Stmts"
-    find_lex $P118, "$/"
-    unless_null $P118, vivify_57
-    new $P118, "Undef"
-  vivify_57:
-    $P119 = $P117."new"($P118 :named("node"))
-    .lex "$past", $P119
-    find_lex $P121, "$/"
-    set $P122, $P121["sentence"]
-    unless_null $P122, vivify_58
-    new $P122, "Undef"
-  vivify_58:
-    defined $I123, $P122
-    unless $I123, for_undef_59
-    iter $P120, $P122
-    new $P133, 'ExceptionHandler'
-    set_addr $P133, loop132_handler
-    $P133."handle_types"(64, 66, 65)
-    push_eh $P133
-  loop132_test:
-    unless $P120, loop132_done
-    shift $P124, $P120
-  loop132_redo:
-    .const 'Sub' $P126 = "18" 
-    capture_lex $P126
-    $P126($P124)
-  loop132_next:
-    goto loop132_test
-  loop132_handler:
+    .param pmc param_121
+    new $P120, 'ExceptionHandler'
+    set_addr $P120, control_119
+    $P120."handle_types"(58)
+    push_eh $P120
+    .lex "$/", param_121
+    get_hll_global $P122, ["PAST"], "Stmts"
+    find_lex $P123, "$/"
+    unless_null $P123, vivify_60
+    new $P123, "Undef"
+  vivify_60:
+    $P124 = $P122."new"($P123 :named("node"))
+    .lex "$past", $P124
+    find_lex $P126, "$/"
+    set $P127, $P126["sentence"]
+    unless_null $P127, vivify_61
+    new $P127, "Undef"
+  vivify_61:
+    defined $I128, $P127
+    unless $I128, for_undef_62
+    iter $P125, $P127
+    new $P138, 'ExceptionHandler'
+    set_addr $P138, loop137_handler
+    $P138."handle_types"(64, 66, 65)
+    push_eh $P138
+  loop137_test:
+    unless $P125, loop137_done
+    shift $P129, $P125
+  loop137_redo:
+    .const 'Sub' $P131 = "18" 
+    capture_lex $P131
+    $P131($P129)
+  loop137_next:
+    goto loop137_test
+  loop137_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P134, exception, 'type'
-    eq $P134, 64, loop132_next
-    eq $P134, 66, loop132_redo
-  loop132_done:
+    getattribute $P139, exception, 'type'
+    eq $P139, 64, loop137_next
+    eq $P139, 66, loop137_redo
+  loop137_done:
     pop_eh 
-  for_undef_59:
-    find_lex $P135, "$/"
-    find_lex $P136, "$past"
-    unless_null $P136, vivify_62
-    new $P136, "Undef"
-  vivify_62:
-    $P137 = $P135."result_object"($P136)
-    .return ($P137)
-  control_114:
+  for_undef_62:
+    find_lex $P140, "$/"
+    find_lex $P141, "$past"
+    unless_null $P141, vivify_65
+    new $P141, "Undef"
+  vivify_65:
+    $P142 = $P140."result_object"($P141)
+    .return ($P142)
+  control_119:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P138, exception, "payload"
-    .return ($P138)
+    getattribute $P143, exception, "payload"
+    .return ($P143)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block125"  :anon :subid("18") :outer("17")
-    .param pmc param_127
-    .lex "$_", param_127
-    find_lex $P128, "$past"
-    unless_null $P128, vivify_60
-    new $P128, "Undef"
-  vivify_60:
-    find_lex $P129, "$_"
-    unless_null $P129, vivify_61
-    new $P129, "Undef"
-  vivify_61:
-    $P130 = $P129."item"()
-    $P131 = $P128."push"($P130)
-    .return ($P131)
+.sub "_block130"  :anon :subid("18") :outer("17")
+    .param pmc param_132
+    .lex "$_", param_132
+    find_lex $P133, "$past"
+    unless_null $P133, vivify_63
+    new $P133, "Undef"
+  vivify_63:
+    find_lex $P134, "$_"
+    unless_null $P134, vivify_64
+    new $P134, "Undef"
+  vivify_64:
+    $P135 = $P134."item"()
+    $P136 = $P133."push"($P135)
+    .return ($P136)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "sentence"  :subid("19") :method :outer("32")
-    .param pmc param_142
-    .param pmc param_143
-    new $P141, 'ExceptionHandler'
-    set_addr $P141, control_140
-    $P141."handle_types"(58)
-    push_eh $P141
-    .lex "$/", param_142
-    .lex "$key", param_143
-    new $P144, "String"
-    assign $P144, "sentence:"
-    find_lex $P145, "$key"
-    unless_null $P145, vivify_63
-    new $P145, "Undef"
-  vivify_63:
-    concat $P146, $P144, $P145
-    "dbg"($P146)
-    find_lex $P147, "$/"
-    find_lex $P148, "$key"
-    unless_null $P148, vivify_64
-    new $P148, "Undef"
-  vivify_64:
-    find_lex $P149, "$/"
-    unless_null $P149, vivify_65
-    new $P149, "Hash"
-  vivify_65:
-    set $P150, $P149[$P148]
+    .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
+    new $P149, "String"
+    assign $P149, "sentence:"
+    find_lex $P150, "$key"
     unless_null $P150, vivify_66
     new $P150, "Undef"
   vivify_66:
-    $P151 = $P150."item"()
-    $P152 = $P147."result_object"($P151)
-    .return ($P152)
-  control_140:
+    concat $P151, $P149, $P150
+    "dbg"($P151)
+    find_lex $P152, "$/"
+    find_lex $P153, "$key"
+    unless_null $P153, vivify_67
+    new $P153, "Undef"
+  vivify_67:
+    find_lex $P154, "$/"
+    unless_null $P154, vivify_68
+    new $P154, "Hash"
+  vivify_68:
+    set $P155, $P154[$P153]
+    unless_null $P155, vivify_69
+    new $P155, "Undef"
+  vivify_69:
+    $P156 = $P155."item"()
+    $P157 = $P152."result_object"($P156)
+    .return ($P157)
+  control_145:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P153, exception, "payload"
-    .return ($P153)
+    getattribute $P158, exception, "payload"
+    .return ($P158)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "dbg"  :subid("20") :outer("32")
-    .param pmc param_157
-    new $P156, 'ExceptionHandler'
-    set_addr $P156, control_155
-    $P156."handle_types"(58)
-    push_eh $P156
-    .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:
+    .param pmc param_162
+    new $P161, 'ExceptionHandler'
+    set_addr $P161, control_160
+    $P161."handle_types"(58)
+    push_eh $P161
+    .lex "$str", param_162
+    new $P165, "Integer"
+    assign $P165, 0
+    if $P165, if_164
+    set $P163, $P165
+    goto if_164_end
+  if_164:
+    .const 'Sub' $P167 = "21" 
+    capture_lex $P167
+    $P170 = $P167()
+    set $P163, $P170
+  if_164_end:
+    .return ($P163)
+  control_160:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P166, exception, "payload"
-    .return ($P166)
+    getattribute $P171, exception, "payload"
+    .return ($P171)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.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)
+.sub "_block166"  :anon :subid("21") :outer("20")
+    find_lex $P168, "$str"
+    unless_null $P168, vivify_70
+    new $P168, "Undef"
+  vivify_70:
+    $P169 = "say"($P168)
+    .return ($P169)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "value"  :subid("22") :method :outer("32")
-    .param pmc param_170
-    .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 $P174, "$/"
-    unless_null $P174, vivify_69
-    new $P174, "Hash"
-  vivify_69:
-    set $P175, $P174[$P173]
-    unless_null $P175, vivify_70
-    new $P175, "Undef"
-  vivify_70:
-    $P176 = $P175."item"()
-    $P177 = $P172."result_object"($P176)
-    .return ($P177)
-  control_168:
+    .param pmc param_175
+    .param pmc param_176
+    new $P174, 'ExceptionHandler'
+    set_addr $P174, control_173
+    $P174."handle_types"(58)
+    push_eh $P174
+    .lex "$/", param_175
+    .lex "$key", param_176
+    find_lex $P177, "$/"
+    find_lex $P178, "$key"
+    unless_null $P178, vivify_71
+    new $P178, "Undef"
+  vivify_71:
+    find_lex $P179, "$/"
+    unless_null $P179, vivify_72
+    new $P179, "Hash"
+  vivify_72:
+    set $P180, $P179[$P178]
+    unless_null $P180, vivify_73
+    new $P180, "Undef"
+  vivify_73:
+    $P181 = $P180."item"()
+    $P182 = $P177."result_object"($P181)
+    .return ($P182)
+  control_173:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P178, exception, "payload"
-    .return ($P178)
+    getattribute $P183, exception, "payload"
+    .return ($P183)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "question"  :subid("23") :method :outer("32")
-    .param pmc param_182
-    .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:
-    $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:
-    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:
+    .param pmc param_187
+    .param pmc param_188
+    new $P186, 'ExceptionHandler'
+    set_addr $P186, control_185
+    $P186."handle_types"(58)
+    push_eh $P186
+    .lex "$/", param_187
+    .lex "$key", param_188
+    new $P189, "String"
+    assign $P189, "question:"
+    find_lex $P190, "$/"
+    set $P191, $P190["key"]
+    unless_null $P191, vivify_74
+    new $P191, "Undef"
+  vivify_74:
+    concat $P192, $P189, $P191
+    "dbg"($P192)
+    get_hll_global $P193, ["PAST"], "Op"
+    new $P194, "String"
+    assign $P194, "goto "
+    find_lex $P195, "$/"
+    set $P196, $P195["roman"]
+    unless_null $P196, vivify_75
+    new $P196, "Undef"
+  vivify_75:
+    concat $P197, $P194, $P196
+    find_lex $P198, "$/"
+    unless_null $P198, vivify_76
+    new $P198, "Undef"
+  vivify_76:
+    $P199 = $P193."new"($P197 :named("inline"), $P198 :named("node"))
+    .lex "$res", $P199
+    find_lex $P200, "$/"
+    find_lex $P201, "$res"
+    unless_null $P201, vivify_77
+    new $P201, "Undef"
+  vivify_77:
+    $P200."result_object"($P201)
+    get_hll_global $P202, ["PAST"], "Op"
+    find_lex $P203, "$key"
+    unless_null $P203, vivify_78
+    new $P203, "Undef"
+  vivify_78:
+    find_lex $P204, "$/"
+    unless_null $P204, vivify_79
+    new $P204, "Undef"
+  vivify_79:
+    $P205 = $P202."new"($P203 :named("name"), "call" :named("pasttype"), $P204 :named("node"))
+    store_lex "$res", $P205
+    find_lex $P207, "$/"
+    set $P208, $P207["value"]
+    unless_null $P208, vivify_80
+    new $P208, "Undef"
+  vivify_80:
+    defined $I209, $P208
+    unless $I209, for_undef_81
+    iter $P206, $P208
+    new $P219, 'ExceptionHandler'
+    set_addr $P219, loop218_handler
+    $P219."handle_types"(64, 66, 65)
+    push_eh $P219
+  loop218_test:
+    unless $P206, loop218_done
+    shift $P210, $P206
+  loop218_redo:
+    .const 'Sub' $P212 = "24" 
+    capture_lex $P212
+    $P212($P210)
+  loop218_next:
+    goto loop218_test
+  loop218_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P202, exception, 'type'
-    eq $P202, 64, loop200_next
-    eq $P202, 66, loop200_redo
-  loop200_done:
+    getattribute $P220, exception, 'type'
+    eq $P220, 64, loop218_next
+    eq $P220, 66, loop218_redo
+  loop218_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:
+  for_undef_81:
+    find_lex $P221, "$/"
+    find_lex $P222, "$res"
+    unless_null $P222, vivify_84
+    new $P222, "Undef"
+  vivify_84:
+    $P223 = $P221."result_object"($P222)
+    .return ($P223)
+  control_185:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P206, exception, "payload"
-    .return ($P206)
+    getattribute $P224, exception, "payload"
+    .return ($P224)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.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:
-    find_lex $P197, "$_"
-    unless_null $P197, vivify_76
-    new $P197, "Undef"
-  vivify_76:
-    $P198 = $P197."item"()
-    $P199 = $P196."push"($P198)
-    .return ($P199)
+.sub "_block211"  :anon :subid("24") :outer("23")
+    .param pmc param_213
+    .lex "$_", param_213
+    find_lex $P214, "$res"
+    unless_null $P214, vivify_82
+    new $P214, "Undef"
+  vivify_82:
+    find_lex $P215, "$_"
+    unless_null $P215, vivify_83
+    new $P215, "Undef"
+  vivify_83:
+    $P216 = $P215."item"()
+    $P217 = $P214."push"($P216)
+    .return ($P217)
 .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:
-    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:
+    .param pmc param_228
+    new $P227, 'ExceptionHandler'
+    set_addr $P227, control_226
+    $P227."handle_types"(58)
+    push_eh $P227
+    .lex "$/", param_228
+    new $P229, "Integer"
+    assign $P229, 1
+    .lex "$value", $P229
+    find_lex $P231, "$/"
+    set $P232, $P231["adjective"]
+    unless_null $P232, vivify_85
+    new $P232, "Undef"
+  vivify_85:
+    defined $I233, $P232
+    unless $I233, for_undef_86
+    iter $P230, $P232
+    new $P241, 'ExceptionHandler'
+    set_addr $P241, loop240_handler
+    $P241."handle_types"(64, 66, 65)
+    push_eh $P241
+  loop240_test:
+    unless $P230, loop240_done
+    shift $P234, $P230
+  loop240_redo:
+    .const 'Sub' $P236 = "26" 
+    capture_lex $P236
+    $P236($P234)
+  loop240_next:
+    goto loop240_test
+  loop240_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P224, exception, 'type'
-    eq $P224, 64, loop222_next
-    eq $P224, 66, loop222_redo
-  loop222_done:
+    getattribute $P242, exception, 'type'
+    eq $P242, 64, loop240_next
+    eq $P242, 66, loop240_redo
+  loop240_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:
+  for_undef_86:
+    find_lex $P243, "$/"
+    get_hll_global $P244, ["PAST"], "Val"
+    find_lex $P245, "$value"
+    unless_null $P245, vivify_88
+    new $P245, "Undef"
+  vivify_88:
+    find_lex $P246, "$/"
+    unless_null $P246, vivify_89
+    new $P246, "Undef"
+  vivify_89:
+    $P247 = $P244."new"($P245 :named("value"), "Integer" :named("returns"), $P246 :named("node"))
+    $P248 = $P243."result_object"($P247)
+    .return ($P248)
+  control_226:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P231, exception, "payload"
-    .return ($P231)
+    getattribute $P249, exception, "payload"
+    .return ($P249)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.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)
+.sub "_block235"  :anon :subid("26") :outer("25")
+    .param pmc param_237
+    .lex "$_", param_237
+    find_lex $P238, "$value"
+    unless_null $P238, vivify_87
+    new $P238, "Undef"
+  vivify_87:
+    mul $P239, $P238, 2
+    store_lex "$value", $P239
+    .return ($P239)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .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
-    get_hll_global $P237, ["PAST"], "Op"
-    find_lex $P238, "$/"
-    unless_null $P238, vivify_83
-    new $P238, "Undef"
-  vivify_83:
-    $P239 = $P237."new"("test" :named("name"), "call" :named("pasttype"), $P238 :named("node"))
-    .lex "$test", $P239
-    find_lex $P240, "$/"
-    get_hll_global $P241, ["PAST"], "Op"
-    find_lex $P242, "$test"
-    unless_null $P242, vivify_84
-    new $P242, "Undef"
-  vivify_84:
-    find_lex $P243, "$/"
-    set $P244, $P243["branch"]
-    unless_null $P244, vivify_85
-    new $P244, "Undef"
-  vivify_85:
-    $P245 = $P244."item"()
-    find_lex $P246, "$k"
-    unless_null $P246, vivify_86
-    new $P246, "Undef"
-  vivify_86:
-    find_lex $P247, "$/"
-    unless_null $P247, vivify_87
-    new $P247, "Undef"
-  vivify_87:
-    $P248 = $P241."new"($P242, $P245, $P246 :named("pasttype"), $P247 :named("node"))
-    $P249 = $P240."result_object"($P248)
-    .return ($P249)
-  control_233:
+    .param pmc param_253
+    .param pmc param_254
+    new $P252, 'ExceptionHandler'
+    set_addr $P252, control_251
+    $P252."handle_types"(58)
+    push_eh $P252
+    .lex "$/", param_253
+    .lex "$k", param_254
+    get_hll_global $P255, ["PAST"], "Var"
+    find_lex $P256, "$/"
+    unless_null $P256, vivify_90
+    new $P256, "Undef"
+  vivify_90:
+    $P257 = $P255."new"("the_condition" :named("name"), 0 :named("isdecl"), "package" :named("scope"), $P256 :named("node"))
+    .lex "$test", $P257
+    find_lex $P258, "$/"
+    get_hll_global $P259, ["PAST"], "Op"
+    find_lex $P260, "$test"
+    unless_null $P260, vivify_91
+    new $P260, "Undef"
+  vivify_91:
+    find_lex $P261, "$/"
+    set $P262, $P261["branch"]
+    unless_null $P262, vivify_92
+    new $P262, "Undef"
+  vivify_92:
+    $P263 = $P262."item"()
+    find_lex $P264, "$k"
+    unless_null $P264, vivify_93
+    new $P264, "Undef"
+  vivify_93:
+    find_lex $P265, "$/"
+    unless_null $P265, vivify_94
+    new $P265, "Undef"
+  vivify_94:
+    $P266 = $P259."new"($P260, $P263, $P264 :named("pasttype"), $P265 :named("node"))
+    $P267 = $P258."result_object"($P266)
+    .return ($P267)
+  control_251:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P250, exception, "payload"
-    .return ($P250)
+    getattribute $P268, exception, "payload"
+    .return ($P268)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "computation"  :subid("28") :method :outer("32")
-    .param pmc param_254
-    .param pmc param_255
-    new $P253, 'ExceptionHandler'
-    set_addr $P253, control_252
-    $P253."handle_types"(58)
-    push_eh $P253
-    .lex "$/", param_254
-    .lex "$key", param_255
-    find_lex $P256, "$/"
-    find_lex $P257, "$key"
-    unless_null $P257, vivify_88
-    new $P257, "Undef"
-  vivify_88:
-    find_lex $P258, "$/"
-    unless_null $P258, vivify_89
-    new $P258, "Hash"
-  vivify_89:
-    set $P259, $P258[$P257]
-    unless_null $P259, vivify_90
-    new $P259, "Undef"
-  vivify_90:
-    $P260 = $P259."item"()
-    $P261 = $P256."result_object"($P260)
-    .return ($P261)
-  control_252:
+    .param pmc param_272
+    .param pmc param_273
+    new $P271, 'ExceptionHandler'
+    set_addr $P271, control_270
+    $P271."handle_types"(58)
+    push_eh $P271
+    .lex "$/", param_272
+    .lex "$key", param_273
+    find_lex $P274, "$/"
+    find_lex $P275, "$key"
+    unless_null $P275, vivify_95
+    new $P275, "Undef"
+  vivify_95:
+    find_lex $P276, "$/"
+    unless_null $P276, vivify_96
+    new $P276, "Hash"
+  vivify_96:
+    set $P277, $P276[$P275]
+    unless_null $P277, vivify_97
+    new $P277, "Undef"
+  vivify_97:
+    $P278 = $P277."item"()
+    $P279 = $P274."result_object"($P278)
+    .return ($P279)
+  control_270:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P262, exception, "payload"
-    .return ($P262)
+    getattribute $P280, exception, "payload"
+    .return ($P280)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "unary"  :subid("29") :method :outer("32")
-    .param pmc param_266
-    .param pmc param_267
-    new $P265, 'ExceptionHandler'
-    set_addr $P265, control_264
-    $P265."handle_types"(58)
-    push_eh $P265
-    .lex "$/", param_266
-    .lex "$key", param_267
-    get_hll_global $P268, ["PAST"], "Op"
-    find_lex $P269, "$key"
-    unless_null $P269, vivify_91
-    new $P269, "Undef"
-  vivify_91:
-    find_lex $P270, "$/"
-    unless_null $P270, vivify_92
-    new $P270, "Undef"
-  vivify_92:
-    $P271 = $P268."new"($P269 :named("name"), "call" :named("pasttype"), $P270 :named("node"))
-    .lex "$res", $P271
-    find_lex $P272, "$res"
-    unless_null $P272, vivify_93
-    new $P272, "Undef"
-  vivify_93:
-    find_lex $P273, "$/"
-    set $P274, $P273["value"]
-    unless_null $P274, vivify_94
-    new $P274, "Undef"
-  vivify_94:
-    $P275 = $P274."item"()
-    $P272."push"($P275)
-    find_lex $P276, "$/"
-    find_lex $P277, "$res"
-    unless_null $P277, vivify_95
-    new $P277, "Undef"
-  vivify_95:
-    $P278 = $P276."result_object"($P277)
-    .return ($P278)
-  control_264:
+    .param pmc param_284
+    .param pmc param_285
+    new $P283, 'ExceptionHandler'
+    set_addr $P283, control_282
+    $P283."handle_types"(58)
+    push_eh $P283
+    .lex "$/", param_284
+    .lex "$key", param_285
+    get_hll_global $P286, ["PAST"], "Op"
+    find_lex $P287, "$key"
+    unless_null $P287, vivify_98
+    new $P287, "Undef"
+  vivify_98:
+    find_lex $P288, "$/"
+    unless_null $P288, vivify_99
+    new $P288, "Undef"
+  vivify_99:
+    $P289 = $P286."new"($P287 :named("name"), "call" :named("pasttype"), $P288 :named("node"))
+    .lex "$res", $P289
+    find_lex $P290, "$res"
+    unless_null $P290, vivify_100
+    new $P290, "Undef"
+  vivify_100:
+    find_lex $P291, "$/"
+    set $P292, $P291["value"]
+    unless_null $P292, vivify_101
+    new $P292, "Undef"
+  vivify_101:
+    $P293 = $P292."item"()
+    $P290."push"($P293)
+    find_lex $P294, "$/"
+    find_lex $P295, "$res"
+    unless_null $P295, vivify_102
+    new $P295, "Undef"
+  vivify_102:
+    $P296 = $P294."result_object"($P295)
+    .return ($P296)
+  control_282:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P279, exception, "payload"
-    .return ($P279)
+    getattribute $P297, exception, "payload"
+    .return ($P297)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
 .sub "binary"  :subid("30") :method :outer("32")
-    .param pmc param_283
-    .param pmc param_284
-    new $P282, 'ExceptionHandler'
-    set_addr $P282, control_281
-    $P282."handle_types"(58)
-    push_eh $P282
-    .lex "$/", param_283
-    .lex "$key", param_284
-    get_hll_global $P285, ["PAST"], "Op"
-    find_lex $P286, "$key"
-    unless_null $P286, vivify_96
-    new $P286, "Undef"
-  vivify_96:
-    find_lex $P287, "$/"
-    unless_null $P287, vivify_97
-    new $P287, "Undef"
-  vivify_97:
-    $P288 = $P285."new"($P286 :named("name"), "call" :named("pasttype"), $P287 :named("node"))
-    .lex "$res", $P288
-    find_lex $P290, "$/"
-    set $P291, $P290["value"]
-    unless_null $P291, vivify_98
-    new $P291, "Undef"
-  vivify_98:
-    defined $I292, $P291
-    unless $I292, for_undef_99
-    iter $P289, $P291
-    new $P302, 'ExceptionHandler'
-    set_addr $P302, loop301_handler
-    $P302."handle_types"(64, 66, 65)
-    push_eh $P302
-  loop301_test:
-    unless $P289, loop301_done
-    shift $P293, $P289
-  loop301_redo:
-    .const 'Sub' $P295 = "31" 
-    capture_lex $P295
-    $P295($P293)
-  loop301_next:
-    goto loop301_test
-  loop301_handler:
+    .param pmc param_301
+    .param pmc param_302
+    new $P300, 'ExceptionHandler'
+    set_addr $P300, control_299
+    $P300."handle_types"(58)
+    push_eh $P300
+    .lex "$/", param_301
+    .lex "$key", param_302
+    get_hll_global $P303, ["PAST"], "Op"
+    find_lex $P304, "$key"
+    unless_null $P304, vivify_103
+    new $P304, "Undef"
+  vivify_103:
+    find_lex $P305, "$/"
+    unless_null $P305, vivify_104
+    new $P305, "Undef"
+  vivify_104:
+    $P306 = $P303."new"($P304 :named("name"), "call" :named("pasttype"), $P305 :named("node"))
+    .lex "$res", $P306
+    find_lex $P308, "$/"
+    set $P309, $P308["value"]
+    unless_null $P309, vivify_105
+    new $P309, "Undef"
+  vivify_105:
+    defined $I310, $P309
+    unless $I310, for_undef_106
+    iter $P307, $P309
+    new $P320, 'ExceptionHandler'
+    set_addr $P320, loop319_handler
+    $P320."handle_types"(64, 66, 65)
+    push_eh $P320
+  loop319_test:
+    unless $P307, loop319_done
+    shift $P311, $P307
+  loop319_redo:
+    .const 'Sub' $P313 = "31" 
+    capture_lex $P313
+    $P313($P311)
+  loop319_next:
+    goto loop319_test
+  loop319_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P303, exception, 'type'
-    eq $P303, 64, loop301_next
-    eq $P303, 66, loop301_redo
-  loop301_done:
+    getattribute $P321, exception, 'type'
+    eq $P321, 64, loop319_next
+    eq $P321, 66, loop319_redo
+  loop319_done:
     pop_eh 
-  for_undef_99:
-    find_lex $P304, "$/"
-    find_lex $P305, "$res"
-    unless_null $P305, vivify_102
-    new $P305, "Undef"
-  vivify_102:
-    $P306 = $P304."result_object"($P305)
-    .return ($P306)
-  control_281:
+  for_undef_106:
+    find_lex $P322, "$/"
+    find_lex $P323, "$res"
+    unless_null $P323, vivify_109
+    new $P323, "Undef"
+  vivify_109:
+    $P324 = $P322."result_object"($P323)
+    .return ($P324)
+  control_299:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P307, exception, "payload"
-    .return ($P307)
+    getattribute $P325, exception, "payload"
+    .return ($P325)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block294"  :anon :subid("31") :outer("30")
-    .param pmc param_296
-    .lex "$_", param_296
-    find_lex $P297, "$res"
-    unless_null $P297, vivify_100
-    new $P297, "Undef"
-  vivify_100:
-    find_lex $P298, "$_"
-    unless_null $P298, vivify_101
-    new $P298, "Undef"
-  vivify_101:
-    $P299 = $P298."item"()
-    $P300 = $P297."push"($P299)
-    .return ($P300)
+.sub "_block312"  :anon :subid("31") :outer("30")
+    .param pmc param_314
+    .lex "$_", param_314
+    find_lex $P315, "$res"
+    unless_null $P315, vivify_107
+    new $P315, "Undef"
+  vivify_107:
+    find_lex $P316, "$_"
+    unless_null $P316, vivify_108
+    new $P316, "Undef"
+  vivify_108:
+    $P317 = $P316."item"()
+    $P318 = $P315."push"($P317)
+    .return ($P318)
 .end
 

File src/gen_builtins.pir

     print "add\n"
     .return ()
 .end
+.namespace []
+.sub 'better'
+    .param int a
+    .param int b
+    new $P0, 'Integer'
+    print "better("
+    print a
+    print ","
+    print b
+    $I0 = a > b
+    set $P0, $I0
+    print ") -> "
+    set_global 'the_condition', $P0
+    print $P0
+    print "\n"
+    .return ($P0)
+.end
 # Local Variables:
 #   mode: pir
 #   fill-column: 100

File src/parser/actions.pm

 class z2::Grammar::Actions;
 
 method TOP($/) {
-    my $past := PAST::Block.new( :node( $/ ) );
-    for $<scene> {
-      $past.push( $( $_ ) );
-    }
-    make $past;
+  my $past := PAST::Block.new( :node( $/ ) );
+  my $tc := PAST::Var.new( 
+    :name('the_condition'), 
+    :isdecl(1), 
+    :scope('package'),
+    :node( $/ ) );
+  $past.push($tc);
+  for $<scene> {
+    $past.push( $( $_ ) );
+  }
+  make $past;
 }
 
 method scene($/) {
 }
 
 method question($/, $key) {
+  dbg("question:"~$<key>);
+  my $res := PAST::Op.new( 
+    :inline("goto "~$<roman>), 
+    :node( $/ ) );
+  make $res;
   my $res := PAST::Op.new( :name( $key ), :pasttype('call'), :node( $/ ) );
   for $<value> {
     $res.push( $( $_ ));
 
 
 method test($/, $k) {
-  my $test := PAST::Op.new( 
-    :name( 'test' ), 
-    :pasttype('call'), 
+  my $test := PAST::Var.new( 
+    :name('the_condition'), 
+    :isdecl(0), 
+    :scope('package'),
     :node( $/ ) );
 
   make PAST::Op.new( 

File t/unless-infinite.t

+Scene I : no special characters. 
+[ENTER romeo and juliet]
+Juliet: Is a mighty king better than you?
+
+Romeo: If so, let us return to scene I.
+
+Juliet: Open your heart! 
+ 
+[Exit Romeo]
+
+Scene I : no special characters. 
+[ENTER romeo and juliet]
+Juliet: Is a mighty king better than you?
+
+Romeo: If so, let us return to scene I.
+
+Juliet: Open your heart! 
+ 
+[Exit Romeo]
+

File z2.pbc

Binary file modified.