Commits

gabriele renzi  committed 0947675

negative values

  • Participants
  • Parent commits 83ad0d3

Comments (0)

Files changed (8)

File src/gen_actions.pir

 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block13" :init :load :subid("34")
-    .const 'Sub' $P328 = "32" 
-    capture_lex $P328
-    .const 'Sub' $P311 = "31" 
-    capture_lex $P311
-    .const 'Sub' $P299 = "30" 
-    capture_lex $P299
-    .const 'Sub' $P280 = "29" 
-    capture_lex $P280
-    .const 'Sub' $P265 = "28" 
-    capture_lex $P265
-    .const 'Sub' $P250 = "27" 
-    capture_lex $P250
+.sub "_block13" :init :load :subid("38")
+    .const 'Sub' $P367 = "36" 
+    capture_lex $P367
+    .const 'Sub' $P350 = "35" 
+    capture_lex $P350
+    .const 'Sub' $P338 = "34" 
+    capture_lex $P338
+    .const 'Sub' $P319 = "33" 
+    capture_lex $P319
+    .const 'Sub' $P304 = "32" 
+    capture_lex $P304
+    .const 'Sub' $P289 = "31" 
+    capture_lex $P289
+    .const 'Sub' $P252 = "27" 
+    capture_lex $P252
     .const 'Sub' $P225 = "25" 
     capture_lex $P225
     .const 'Sub' $P184 = "23" 
         $P2 = $P0.'new_class'($P1)
       subclass_done:
         pop_eh
-    .const 'Sub' $P328 = "32" 
-    capture_lex $P328
-    .return ($P328)
+    .const 'Sub' $P367 = "36" 
+    capture_lex $P367
+    .return ($P367)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "TOP"  :subid("11") :method :outer("34")
+.sub "TOP"  :subid("11") :method :outer("38")
     .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_35
+    unless_null $P20, vivify_39
     new $P20, "Undef"
-  vivify_35:
+  vivify_39:
     $P21 = $P19."new"($P20 :named("node"))
     .lex "$past", $P21
     get_hll_global $P22, ["PAST"], "Var"
     find_lex $P23, "$/"
-    unless_null $P23, vivify_36
+    unless_null $P23, vivify_40
     new $P23, "Undef"
-  vivify_36:
+  vivify_40:
     $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_37
+    unless_null $P25, vivify_41
     new $P25, "Undef"
-  vivify_37:
+  vivify_41:
     find_lex $P26, "$tc"
-    unless_null $P26, vivify_38
+    unless_null $P26, vivify_42
     new $P26, "Undef"
-  vivify_38:
+  vivify_42:
     $P25."push"($P26)
     find_lex $P28, "$/"
     set $P29, $P28["scene"]
-    unless_null $P29, vivify_39
+    unless_null $P29, vivify_43
     new $P29, "Undef"
-  vivify_39:
+  vivify_43:
     defined $I30, $P29
-    unless $I30, for_undef_40
+    unless $I30, for_undef_44
     iter $P27, $P29
     new $P40, 'ExceptionHandler'
     set_addr $P40, loop39_handler
     eq $P41, 66, loop39_redo
   loop39_done:
     pop_eh 
-  for_undef_40:
+  for_undef_44:
     find_lex $P42, "$/"
     find_lex $P43, "$past"
-    unless_null $P43, vivify_43
+    unless_null $P43, vivify_47
     new $P43, "Undef"
-  vivify_43:
+  vivify_47:
     $P44 = $P42."result_object"($P43)
     .return ($P44)
   control_16:
     .param pmc param_34
     .lex "$_", param_34
     find_lex $P35, "$past"
-    unless_null $P35, vivify_41
+    unless_null $P35, vivify_45
     new $P35, "Undef"
-  vivify_41:
+  vivify_45:
     find_lex $P36, "$_"
-    unless_null $P36, vivify_42
+    unless_null $P36, vivify_46
     new $P36, "Undef"
-  vivify_42:
+  vivify_46:
     $P37 = $P36."item"()
     $P38 = $P35."push"($P37)
     .return ($P38)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "scene"  :subid("13") :method :outer("34")
+.sub "scene"  :subid("13") :method :outer("38")
     .param pmc param_49
     new $P48, 'ExceptionHandler'
     set_addr $P48, control_47
     get_hll_global $P50, ["PAST"], "Stmts"
     find_lex $P51, "$/"
     set $P52, $P51["roman"]
-    unless_null $P52, vivify_44
+    unless_null $P52, vivify_48
     new $P52, "Undef"
-  vivify_44:
+  vivify_48:
     find_lex $P53, "$/"
-    unless_null $P53, vivify_45
+    unless_null $P53, vivify_49
     new $P53, "Undef"
-  vivify_45:
+  vivify_49:
     $P54 = $P50."new"($P52 :named("name"), $P53 :named("node"))
     .lex "$past", $P54
     get_hll_global $P55, ["PAST"], "Op"
     assign $P56, ""
     find_lex $P57, "$/"
     set $P58, $P57["roman"]
-    unless_null $P58, vivify_46
+    unless_null $P58, vivify_50
     new $P58, "Undef"
-  vivify_46:
+  vivify_50:
     concat $P59, $P56, $P58
     concat $P60, $P59, ":"
     find_lex $P61, "$/"
-    unless_null $P61, vivify_47
+    unless_null $P61, vivify_51
     new $P61, "Undef"
-  vivify_47:
+  vivify_51:
     $P62 = $P55."new"($P60 :named("inline"), $P61 :named("node"))
     .lex "$lbl", $P62
     find_lex $P63, "$past"
-    unless_null $P63, vivify_48
+    unless_null $P63, vivify_52
     new $P63, "Undef"
-  vivify_48:
+  vivify_52:
     find_lex $P64, "$lbl"
-    unless_null $P64, vivify_49
+    unless_null $P64, vivify_53
     new $P64, "Undef"
-  vivify_49:
+  vivify_53:
     $P63."push"($P64)
     find_lex $P66, "$/"
     set $P67, $P66["line"]
-    unless_null $P67, vivify_50
+    unless_null $P67, vivify_54
     new $P67, "Undef"
-  vivify_50:
+  vivify_54:
     defined $I68, $P67
-    unless $I68, for_undef_51
+    unless $I68, for_undef_55
     iter $P65, $P67
     new $P78, 'ExceptionHandler'
     set_addr $P78, loop77_handler
     eq $P79, 66, loop77_redo
   loop77_done:
     pop_eh 
-  for_undef_51:
+  for_undef_55:
     find_lex $P80, "$/"
     find_lex $P81, "$past"
-    unless_null $P81, vivify_54
+    unless_null $P81, vivify_58
     new $P81, "Undef"
-  vivify_54:
+  vivify_58:
     $P82 = $P80."result_object"($P81)
     .return ($P82)
   control_47:
     .param pmc param_72
     .lex "$_", param_72
     find_lex $P73, "$past"
-    unless_null $P73, vivify_52
+    unless_null $P73, vivify_56
     new $P73, "Undef"
-  vivify_52:
+  vivify_56:
     find_lex $P74, "$_"
-    unless_null $P74, vivify_53
+    unless_null $P74, vivify_57
     new $P74, "Undef"
-  vivify_53:
+  vivify_57:
     $P75 = $P74."item"()
     $P76 = $P73."push"($P75)
     .return ($P76)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "branch"  :subid("15") :method :outer("34")
+.sub "branch"  :subid("15") :method :outer("38")
     .param pmc param_87
     new $P86, 'ExceptionHandler'
     set_addr $P86, control_85
     assign $P88, "branch:"
     find_lex $P89, "$/"
     set $P90, $P89["roman"]
-    unless_null $P90, vivify_55
+    unless_null $P90, vivify_59
     new $P90, "Undef"
-  vivify_55:
+  vivify_59:
     concat $P91, $P88, $P90
     "dbg"($P91)
     get_hll_global $P92, ["PAST"], "Op"
     assign $P93, "goto "
     find_lex $P94, "$/"
     set $P95, $P94["roman"]
-    unless_null $P95, vivify_56
+    unless_null $P95, vivify_60
     new $P95, "Undef"
-  vivify_56:
+  vivify_60:
     concat $P96, $P93, $P95
     find_lex $P97, "$/"
-    unless_null $P97, vivify_57
+    unless_null $P97, vivify_61
     new $P97, "Undef"
-  vivify_57:
+  vivify_61:
     $P98 = $P92."new"($P96 :named("inline"), $P97 :named("node"))
     .lex "$res", $P98
     find_lex $P99, "$/"
     find_lex $P100, "$res"
-    unless_null $P100, vivify_58
+    unless_null $P100, vivify_62
     new $P100, "Undef"
-  vivify_58:
+  vivify_62:
     $P101 = $P99."result_object"($P100)
     .return ($P101)
   control_85:
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "io"  :subid("16") :method :outer("34")
+.sub "io"  :subid("16") :method :outer("38")
     .param pmc param_106
     .param pmc param_107
     new $P105, 'ExceptionHandler'
     new $P108, "String"
     assign $P108, "io:"
     find_lex $P109, "$key"
-    unless_null $P109, vivify_59
+    unless_null $P109, vivify_63
     new $P109, "Undef"
-  vivify_59:
+  vivify_63:
     concat $P110, $P108, $P109
     "dbg"($P110)
     get_hll_global $P111, ["PAST"], "Op"
     find_lex $P112, "$/"
-    unless_null $P112, vivify_60
+    unless_null $P112, vivify_64
     new $P112, "Undef"
-  vivify_60:
+  vivify_64:
     $P113 = $P111."new"("say2" :named("name"), "call" :named("pasttype"), $P112 :named("node"))
     .lex "$res", $P113
     "dbg"("ok")
     find_lex $P114, "$/"
     find_lex $P115, "$res"
-    unless_null $P115, vivify_61
+    unless_null $P115, vivify_65
     new $P115, "Undef"
-  vivify_61:
+  vivify_65:
     $P116 = $P114."result_object"($P115)
     .return ($P116)
   control_104:
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "line"  :subid("17") :method :outer("34")
+.sub "line"  :subid("17") :method :outer("38")
     .param pmc param_121
     new $P120, 'ExceptionHandler'
     set_addr $P120, control_119
     .lex "$/", param_121
     get_hll_global $P122, ["PAST"], "Stmts"
     find_lex $P123, "$/"
-    unless_null $P123, vivify_62
+    unless_null $P123, vivify_66
     new $P123, "Undef"
-  vivify_62:
+  vivify_66:
     $P124 = $P122."new"($P123 :named("node"))
     .lex "$past", $P124
     find_lex $P126, "$/"
     set $P127, $P126["sentence"]
-    unless_null $P127, vivify_63
+    unless_null $P127, vivify_67
     new $P127, "Undef"
-  vivify_63:
+  vivify_67:
     defined $I128, $P127
-    unless $I128, for_undef_64
+    unless $I128, for_undef_68
     iter $P125, $P127
     new $P138, 'ExceptionHandler'
     set_addr $P138, loop137_handler
     eq $P139, 66, loop137_redo
   loop137_done:
     pop_eh 
-  for_undef_64:
+  for_undef_68:
     find_lex $P140, "$/"
     find_lex $P141, "$past"
-    unless_null $P141, vivify_67
+    unless_null $P141, vivify_71
     new $P141, "Undef"
-  vivify_67:
+  vivify_71:
     $P142 = $P140."result_object"($P141)
     .return ($P142)
   control_119:
     .param pmc param_132
     .lex "$_", param_132
     find_lex $P133, "$past"
-    unless_null $P133, vivify_65
+    unless_null $P133, vivify_69
     new $P133, "Undef"
-  vivify_65:
+  vivify_69:
     find_lex $P134, "$_"
-    unless_null $P134, vivify_66
+    unless_null $P134, vivify_70
     new $P134, "Undef"
-  vivify_66:
+  vivify_70:
     $P135 = $P134."item"()
     $P136 = $P133."push"($P135)
     .return ($P136)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "sentence"  :subid("19") :method :outer("34")
+.sub "sentence"  :subid("19") :method :outer("38")
     .param pmc param_147
     .param pmc param_148
     new $P146, 'ExceptionHandler'
     new $P149, "String"
     assign $P149, "sentence:"
     find_lex $P150, "$key"
-    unless_null $P150, vivify_68
+    unless_null $P150, vivify_72
     new $P150, "Undef"
-  vivify_68:
+  vivify_72:
     concat $P151, $P149, $P150
     "dbg"($P151)
     find_lex $P152, "$/"
     find_lex $P153, "$key"
-    unless_null $P153, vivify_69
+    unless_null $P153, vivify_73
     new $P153, "Undef"
-  vivify_69:
+  vivify_73:
     find_lex $P154, "$/"
-    unless_null $P154, vivify_70
+    unless_null $P154, vivify_74
     new $P154, "Hash"
-  vivify_70:
+  vivify_74:
     set $P155, $P154[$P153]
-    unless_null $P155, vivify_71
+    unless_null $P155, vivify_75
     new $P155, "Undef"
-  vivify_71:
+  vivify_75:
     $P156 = $P155."item"()
     $P157 = $P152."result_object"($P156)
     .return ($P157)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "dbg"  :subid("20") :outer("34")
+.sub "dbg"  :subid("20") :outer("38")
     .param pmc param_162
     new $P161, 'ExceptionHandler'
     set_addr $P161, control_160
 .namespace ["z2";"Grammar";"Actions"]
 .sub "_block166"  :anon :subid("21") :outer("20")
     find_lex $P168, "$str"
-    unless_null $P168, vivify_72
+    unless_null $P168, vivify_76
     new $P168, "Undef"
-  vivify_72:
+  vivify_76:
     $P169 = "say"($P168)
     .return ($P169)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "value"  :subid("22") :method :outer("34")
+.sub "value"  :subid("22") :method :outer("38")
     .param pmc param_175
     .param pmc param_176
     new $P174, 'ExceptionHandler'
     .lex "$key", param_176
     find_lex $P177, "$/"
     find_lex $P178, "$key"
-    unless_null $P178, vivify_73
+    unless_null $P178, vivify_77
     new $P178, "Undef"
-  vivify_73:
+  vivify_77:
     find_lex $P179, "$/"
-    unless_null $P179, vivify_74
+    unless_null $P179, vivify_78
     new $P179, "Hash"
-  vivify_74:
+  vivify_78:
     set $P180, $P179[$P178]
-    unless_null $P180, vivify_75
+    unless_null $P180, vivify_79
     new $P180, "Undef"
-  vivify_75:
+  vivify_79:
     $P181 = $P180."item"()
     $P182 = $P177."result_object"($P181)
     .return ($P182)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "question"  :subid("23") :method :outer("34")
+.sub "question"  :subid("23") :method :outer("38")
     .param pmc param_187
     .param pmc param_188
     new $P186, 'ExceptionHandler'
     assign $P189, "question:"
     find_lex $P190, "$/"
     set $P191, $P190["key"]
-    unless_null $P191, vivify_76
+    unless_null $P191, vivify_80
     new $P191, "Undef"
-  vivify_76:
+  vivify_80:
     concat $P192, $P189, $P191
     "dbg"($P192)
     get_hll_global $P193, ["PAST"], "Op"
     assign $P194, "goto "
     find_lex $P195, "$/"
     set $P196, $P195["roman"]
-    unless_null $P196, vivify_77
+    unless_null $P196, vivify_81
     new $P196, "Undef"
-  vivify_77:
+  vivify_81:
     concat $P197, $P194, $P196
     find_lex $P198, "$/"
-    unless_null $P198, vivify_78
+    unless_null $P198, vivify_82
     new $P198, "Undef"
-  vivify_78:
+  vivify_82:
     $P199 = $P193."new"($P197 :named("inline"), $P198 :named("node"))
     .lex "$res", $P199
     find_lex $P200, "$/"
     find_lex $P201, "$res"
-    unless_null $P201, vivify_79
+    unless_null $P201, vivify_83
     new $P201, "Undef"
-  vivify_79:
+  vivify_83:
     $P200."result_object"($P201)
     get_hll_global $P202, ["PAST"], "Op"
     find_lex $P203, "$key"
-    unless_null $P203, vivify_80
+    unless_null $P203, vivify_84
     new $P203, "Undef"
-  vivify_80:
+  vivify_84:
     find_lex $P204, "$/"
-    unless_null $P204, vivify_81
+    unless_null $P204, vivify_85
     new $P204, "Undef"
-  vivify_81:
+  vivify_85:
     $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_82
+    unless_null $P208, vivify_86
     new $P208, "Undef"
-  vivify_82:
+  vivify_86:
     defined $I209, $P208
-    unless $I209, for_undef_83
+    unless $I209, for_undef_87
     iter $P206, $P208
     new $P219, 'ExceptionHandler'
     set_addr $P219, loop218_handler
     eq $P220, 66, loop218_redo
   loop218_done:
     pop_eh 
-  for_undef_83:
+  for_undef_87:
     find_lex $P221, "$/"
     find_lex $P222, "$res"
-    unless_null $P222, vivify_86
+    unless_null $P222, vivify_90
     new $P222, "Undef"
-  vivify_86:
+  vivify_90:
     $P223 = $P221."result_object"($P222)
     .return ($P223)
   control_185:
     .param pmc param_213
     .lex "$_", param_213
     find_lex $P214, "$res"
-    unless_null $P214, vivify_84
+    unless_null $P214, vivify_88
     new $P214, "Undef"
-  vivify_84:
+  vivify_88:
     find_lex $P215, "$_"
-    unless_null $P215, vivify_85
+    unless_null $P215, vivify_89
     new $P215, "Undef"
-  vivify_85:
+  vivify_89:
     $P216 = $P215."item"()
     $P217 = $P214."push"($P216)
     .return ($P217)
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "immediate"  :subid("25") :method :outer("34")
+.sub "immediate"  :subid("25") :method :outer("38")
     .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_87
-    new $P232, "Undef"
-  vivify_87:
-    defined $I233, $P232
-    unless $I233, for_undef_88
-    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:
+    find_lex $P229, "$/"
+    set $P230, $P229["noun"]
+    unless_null $P230, vivify_91
+    new $P230, "Undef"
+  vivify_91:
+    $P231 = $P230."item"()
+    .lex "$value", $P231
+    find_lex $P233, "$/"
+    set $P234, $P233["adjective"]
+    unless_null $P234, vivify_92
+    new $P234, "Undef"
+  vivify_92:
+    defined $I235, $P234
+    unless $I235, for_undef_93
+    iter $P232, $P234
+    new $P243, 'ExceptionHandler'
+    set_addr $P243, loop242_handler
+    $P243."handle_types"(64, 66, 65)
+    push_eh $P243
+  loop242_test:
+    unless $P232, loop242_done
+    shift $P236, $P232
+  loop242_redo:
+    .const 'Sub' $P238 = "26" 
+    capture_lex $P238
+    $P238($P236)
+  loop242_next:
+    goto loop242_test
+  loop242_handler:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P242, exception, 'type'
-    eq $P242, 64, loop240_next
-    eq $P242, 66, loop240_redo
-  loop240_done:
+    getattribute $P244, exception, 'type'
+    eq $P244, 64, loop242_next
+    eq $P244, 66, loop242_redo
+  loop242_done:
     pop_eh 
-  for_undef_88:
-    find_lex $P243, "$/"
-    get_hll_global $P244, ["PAST"], "Val"
-    find_lex $P245, "$value"
-    unless_null $P245, vivify_90
-    new $P245, "Undef"
-  vivify_90:
-    find_lex $P246, "$/"
-    unless_null $P246, vivify_91
-    new $P246, "Undef"
-  vivify_91:
-    $P247 = $P244."new"($P245 :named("value"), "Integer" :named("returns"), $P246 :named("node"))
-    $P248 = $P243."result_object"($P247)
-    .return ($P248)
+  for_undef_93:
+    find_lex $P245, "$/"
+    get_hll_global $P246, ["PAST"], "Val"
+    find_lex $P247, "$value"
+    unless_null $P247, vivify_95
+    new $P247, "Undef"
+  vivify_95:
+    find_lex $P248, "$/"
+    unless_null $P248, vivify_96
+    new $P248, "Undef"
+  vivify_96:
+    $P249 = $P246."new"($P247 :named("value"), "Integer" :named("returns"), $P248 :named("node"))
+    $P250 = $P245."result_object"($P249)
+    .return ($P250)
   control_226:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P249, exception, "payload"
-    .return ($P249)
+    getattribute $P251, exception, "payload"
+    .return ($P251)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block235"  :anon :subid("26") :outer("25")
-    .param pmc param_237
-    .lex "$_", param_237
-    find_lex $P238, "$value"
-    unless_null $P238, vivify_89
-    new $P238, "Undef"
-  vivify_89:
-    mul $P239, $P238, 2
-    store_lex "$value", $P239
-    .return ($P239)
+.sub "_block237"  :anon :subid("26") :outer("25")
+    .param pmc param_239
+    .lex "$_", param_239
+    find_lex $P240, "$value"
+    unless_null $P240, vivify_94
+    new $P240, "Undef"
+  vivify_94:
+    mul $P241, $P240, 2
+    store_lex "$value", $P241
+    .return ($P241)
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "tap"  :subid("27") :method :outer("34")
-    .param pmc param_253
-    new $P252, 'ExceptionHandler'
-    set_addr $P252, control_251
-    $P252."handle_types"(58)
-    push_eh $P252
-    .lex "$/", param_253
-    get_hll_global $P254, ["PAST"], "Op"
-    find_lex $P255, "$/"
-    unless_null $P255, vivify_92
-    new $P255, "Undef"
-  vivify_92:
-    $P256 = $P254."new"("tap" :named("name"), "call" :named("pasttype"), $P255 :named("node"))
-    .lex "$res", $P256
-    find_lex $P257, "$res"
-    unless_null $P257, vivify_93
-    new $P257, "Undef"
-  vivify_93:
-    find_lex $P258, "$/"
-    set $P259, $P258["value"]
-    unless_null $P259, vivify_94
+.sub "noun"  :subid("27") :method :outer("38")
+    .param pmc param_255
+    .param pmc param_256
+    new $P254, 'ExceptionHandler'
+    set_addr $P254, control_253
+    $P254."handle_types"(58)
+    push_eh $P254
+    .lex "$/", param_255
+    .lex "$k", param_256
+    find_lex $P259, "$k"
+    unless_null $P259, vivify_97
     new $P259, "Undef"
-  vivify_94:
-    $P260 = $P259."item"()
-    $P257."push"($P260)
-    find_lex $P261, "$/"
-    find_lex $P262, "$res"
-    unless_null $P262, vivify_95
-    new $P262, "Undef"
-  vivify_95:
-    $P263 = $P261."result_object"($P262)
-    .return ($P263)
-  control_251:
+  vivify_97:
+    set $S260, $P259
+    iseq $I261, $S260, "one"
+    if $I261, if_258
+    find_lex $P269, "$k"
+    unless_null $P269, vivify_98
+    new $P269, "Undef"
+  vivify_98:
+    set $S270, $P269
+    iseq $I271, $S270, "minus_one"
+    if $I271, if_268
+    find_lex $P281, "$k"
+    unless_null $P281, vivify_99
+    new $P281, "Undef"
+  vivify_99:
+    set $S282, $P281
+    iseq $I283, $S282, "lookup"
+    if $I283, if_280
+    new $P279, 'Integer'
+    set $P279, $I283
+    goto if_280_end
+  if_280:
+    .const 'Sub' $P285 = "30" 
+    capture_lex $P285
+    $P287 = $P285()
+    set $P279, $P287
+  if_280_end:
+    set $P267, $P279
+    goto if_268_end
+  if_268:
+    .const 'Sub' $P273 = "29" 
+    capture_lex $P273
+    $P278 = $P273()
+    set $P267, $P278
+  if_268_end:
+    set $P257, $P267
+    goto if_258_end
+  if_258:
+    .const 'Sub' $P263 = "28" 
+    capture_lex $P263
+    $P266 = $P263()
+    set $P257, $P266
+  if_258_end:
+    .return ($P257)
+  control_253:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P264, exception, "payload"
-    .return ($P264)
+    getattribute $P288, exception, "payload"
+    .return ($P288)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "plan"  :subid("28") :method :outer("34")
-    .param pmc param_268
-    new $P267, 'ExceptionHandler'
-    set_addr $P267, control_266
-    $P267."handle_types"(58)
-    push_eh $P267
-    .lex "$/", param_268
-    get_hll_global $P269, ["PAST"], "Op"
-    find_lex $P270, "$/"
-    unless_null $P270, vivify_96
-    new $P270, "Undef"
-  vivify_96:
-    $P271 = $P269."new"("plan" :named("name"), "call" :named("pasttype"), $P270 :named("node"))
-    .lex "$res", $P271
-    find_lex $P272, "$res"
-    unless_null $P272, vivify_97
-    new $P272, "Undef"
-  vivify_97:
-    find_lex $P273, "$/"
-    set $P274, $P273["value"]
-    unless_null $P274, vivify_98
-    new $P274, "Undef"
-  vivify_98:
-    $P275 = $P274."item"()
-    $P272."push"($P275)
-    find_lex $P276, "$/"
-    find_lex $P277, "$res"
-    unless_null $P277, vivify_99
-    new $P277, "Undef"
-  vivify_99:
-    $P278 = $P276."result_object"($P277)
-    .return ($P278)
-  control_266:
+.sub "_block284"  :anon :subid("30") :outer("27")
+    "say"("you")
+    $P286 = "panic"()
+    .return ($P286)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "_block272"  :anon :subid("29") :outer("27")
+    find_lex $P274, "$/"
+    new $P275, "Integer"
+    assign $P275, 1
+    n_neg $P276, $P275
+    $P277 = $P274."result_object"($P276)
+    .return ($P277)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "_block262"  :anon :subid("28") :outer("27")
+    find_lex $P264, "$/"
+    $P265 = $P264."result_object"(1)
+    .return ($P265)
+.end
+
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "tap"  :subid("31") :method :outer("38")
+    .param pmc param_292
+    new $P291, 'ExceptionHandler'
+    set_addr $P291, control_290
+    $P291."handle_types"(58)
+    push_eh $P291
+    .lex "$/", param_292
+    get_hll_global $P293, ["PAST"], "Op"
+    find_lex $P294, "$/"
+    unless_null $P294, vivify_100
+    new $P294, "Undef"
+  vivify_100:
+    $P295 = $P293."new"("tap" :named("name"), "call" :named("pasttype"), $P294 :named("node"))
+    .lex "$res", $P295
+    find_lex $P296, "$res"
+    unless_null $P296, vivify_101
+    new $P296, "Undef"
+  vivify_101:
+    find_lex $P297, "$/"
+    set $P298, $P297["value"]
+    unless_null $P298, vivify_102
+    new $P298, "Undef"
+  vivify_102:
+    $P299 = $P298."item"()
+    $P296."push"($P299)
+    find_lex $P300, "$/"
+    find_lex $P301, "$res"
+    unless_null $P301, vivify_103
+    new $P301, "Undef"
+  vivify_103:
+    $P302 = $P300."result_object"($P301)
+    .return ($P302)
+  control_290:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P279, exception, "payload"
-    .return ($P279)
+    getattribute $P303, exception, "payload"
+    .return ($P303)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "test"  :subid("29") :method :outer("34")
-    .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 "$k", param_284
-    get_hll_global $P285, ["PAST"], "Var"
-    find_lex $P286, "$/"
-    unless_null $P286, vivify_100
-    new $P286, "Undef"
-  vivify_100:
-    $P287 = $P285."new"("the_condition" :named("name"), 0 :named("isdecl"), "package" :named("scope"), $P286 :named("node"))
-    .lex "$test", $P287
-    find_lex $P288, "$/"
-    get_hll_global $P289, ["PAST"], "Op"
-    find_lex $P290, "$test"
-    unless_null $P290, vivify_101
-    new $P290, "Undef"
-  vivify_101:
-    find_lex $P291, "$/"
-    set $P292, $P291["branch"]
-    unless_null $P292, vivify_102
-    new $P292, "Undef"
-  vivify_102:
-    $P293 = $P292."item"()
-    find_lex $P294, "$k"
-    unless_null $P294, vivify_103
-    new $P294, "Undef"
-  vivify_103:
-    find_lex $P295, "$/"
-    unless_null $P295, vivify_104
-    new $P295, "Undef"
+.sub "plan"  :subid("32") :method :outer("38")
+    .param pmc param_307
+    new $P306, 'ExceptionHandler'
+    set_addr $P306, control_305
+    $P306."handle_types"(58)
+    push_eh $P306
+    .lex "$/", param_307
+    get_hll_global $P308, ["PAST"], "Op"
+    find_lex $P309, "$/"
+    unless_null $P309, vivify_104
+    new $P309, "Undef"
   vivify_104:
-    $P296 = $P289."new"($P290, $P293, $P294 :named("pasttype"), $P295 :named("node"))
-    $P297 = $P288."result_object"($P296)
-    .return ($P297)
-  control_281:
+    $P310 = $P308."new"("plan" :named("name"), "call" :named("pasttype"), $P309 :named("node"))
+    .lex "$res", $P310
+    find_lex $P311, "$res"
+    unless_null $P311, vivify_105
+    new $P311, "Undef"
+  vivify_105:
+    find_lex $P312, "$/"
+    set $P313, $P312["value"]
+    unless_null $P313, vivify_106
+    new $P313, "Undef"
+  vivify_106:
+    $P314 = $P313."item"()
+    $P311."push"($P314)
+    find_lex $P315, "$/"
+    find_lex $P316, "$res"
+    unless_null $P316, vivify_107
+    new $P316, "Undef"
+  vivify_107:
+    $P317 = $P315."result_object"($P316)
+    .return ($P317)
+  control_305:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P298, exception, "payload"
-    .return ($P298)
+    getattribute $P318, exception, "payload"
+    .return ($P318)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "computation"  :subid("30") :method :outer("34")
-    .param pmc param_302
-    .param pmc param_303
-    new $P301, 'ExceptionHandler'
-    set_addr $P301, control_300
-    $P301."handle_types"(58)
-    push_eh $P301
-    .lex "$/", param_302
-    .lex "$key", param_303
-    find_lex $P304, "$/"
-    find_lex $P305, "$key"
-    unless_null $P305, vivify_105
-    new $P305, "Undef"
-  vivify_105:
-    find_lex $P306, "$/"
-    unless_null $P306, vivify_106
-    new $P306, "Hash"
-  vivify_106:
-    set $P307, $P306[$P305]
-    unless_null $P307, vivify_107
-    new $P307, "Undef"
-  vivify_107:
-    $P308 = $P307."item"()
-    $P309 = $P304."result_object"($P308)
-    .return ($P309)
-  control_300:
+.sub "test"  :subid("33") :method :outer("38")
+    .param pmc param_322
+    .param pmc param_323
+    new $P321, 'ExceptionHandler'
+    set_addr $P321, control_320
+    $P321."handle_types"(58)
+    push_eh $P321
+    .lex "$/", param_322
+    .lex "$k", param_323
+    get_hll_global $P324, ["PAST"], "Var"
+    find_lex $P325, "$/"
+    unless_null $P325, vivify_108
+    new $P325, "Undef"
+  vivify_108:
+    $P326 = $P324."new"("the_condition" :named("name"), 0 :named("isdecl"), "package" :named("scope"), $P325 :named("node"))
+    .lex "$test", $P326
+    find_lex $P327, "$/"
+    get_hll_global $P328, ["PAST"], "Op"
+    find_lex $P329, "$test"
+    unless_null $P329, vivify_109
+    new $P329, "Undef"
+  vivify_109:
+    find_lex $P330, "$/"
+    set $P331, $P330["branch"]
+    unless_null $P331, vivify_110
+    new $P331, "Undef"
+  vivify_110:
+    $P332 = $P331."item"()
+    find_lex $P333, "$k"
+    unless_null $P333, vivify_111
+    new $P333, "Undef"
+  vivify_111:
+    find_lex $P334, "$/"
+    unless_null $P334, vivify_112
+    new $P334, "Undef"
+  vivify_112:
+    $P335 = $P328."new"($P329, $P332, $P333 :named("pasttype"), $P334 :named("node"))
+    $P336 = $P327."result_object"($P335)
+    .return ($P336)
+  control_320:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P310, exception, "payload"
-    .return ($P310)
+    getattribute $P337, exception, "payload"
+    .return ($P337)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "unary"  :subid("31") :method :outer("34")
-    .param pmc param_314
-    .param pmc param_315
-    new $P313, 'ExceptionHandler'
-    set_addr $P313, control_312
-    $P313."handle_types"(58)
-    push_eh $P313
-    .lex "$/", param_314
-    .lex "$key", param_315
-    get_hll_global $P316, ["PAST"], "Op"
-    find_lex $P317, "$key"
-    unless_null $P317, vivify_108
-    new $P317, "Undef"
-  vivify_108:
-    find_lex $P318, "$/"
-    unless_null $P318, vivify_109
-    new $P318, "Undef"
-  vivify_109:
-    $P319 = $P316."new"($P317 :named("name"), "call" :named("pasttype"), $P318 :named("node"))
-    .lex "$res", $P319
-    find_lex $P320, "$res"
-    unless_null $P320, vivify_110
-    new $P320, "Undef"
-  vivify_110:
-    find_lex $P321, "$/"
-    set $P322, $P321["value"]
-    unless_null $P322, vivify_111
-    new $P322, "Undef"
-  vivify_111:
-    $P323 = $P322."item"()
-    $P320."push"($P323)
-    find_lex $P324, "$/"
-    find_lex $P325, "$res"
-    unless_null $P325, vivify_112
-    new $P325, "Undef"
-  vivify_112:
-    $P326 = $P324."result_object"($P325)
-    .return ($P326)
-  control_312:
+.sub "computation"  :subid("34") :method :outer("38")
+    .param pmc param_341
+    .param pmc param_342
+    new $P340, 'ExceptionHandler'
+    set_addr $P340, control_339
+    $P340."handle_types"(58)
+    push_eh $P340
+    .lex "$/", param_341
+    .lex "$key", param_342
+    find_lex $P343, "$/"
+    find_lex $P344, "$key"
+    unless_null $P344, vivify_113
+    new $P344, "Undef"
+  vivify_113:
+    find_lex $P345, "$/"
+    unless_null $P345, vivify_114
+    new $P345, "Hash"
+  vivify_114:
+    set $P346, $P345[$P344]
+    unless_null $P346, vivify_115
+    new $P346, "Undef"
+  vivify_115:
+    $P347 = $P346."item"()
+    $P348 = $P343."result_object"($P347)
+    .return ($P348)
+  control_339:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P327, exception, "payload"
-    .return ($P327)
+    getattribute $P349, exception, "payload"
+    .return ($P349)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "binary"  :subid("32") :method :outer("34")
-    .param pmc param_331
-    .param pmc param_332
-    new $P330, 'ExceptionHandler'
-    set_addr $P330, control_329
-    $P330."handle_types"(58)
-    push_eh $P330
-    .lex "$/", param_331
-    .lex "$key", param_332
-    get_hll_global $P333, ["PAST"], "Op"
-    find_lex $P334, "$key"
-    unless_null $P334, vivify_113
-    new $P334, "Undef"
-  vivify_113:
-    find_lex $P335, "$/"
-    unless_null $P335, vivify_114
-    new $P335, "Undef"
-  vivify_114:
-    $P336 = $P333."new"($P334 :named("name"), "call" :named("pasttype"), $P335 :named("node"))
-    .lex "$res", $P336
-    find_lex $P338, "$/"
-    set $P339, $P338["value"]
-    unless_null $P339, vivify_115
-    new $P339, "Undef"
-  vivify_115:
-    defined $I340, $P339
-    unless $I340, for_undef_116
-    iter $P337, $P339
-    new $P350, 'ExceptionHandler'
-    set_addr $P350, loop349_handler
-    $P350."handle_types"(64, 66, 65)
-    push_eh $P350
-  loop349_test:
-    unless $P337, loop349_done
-    shift $P341, $P337
-  loop349_redo:
-    .const 'Sub' $P343 = "33" 
-    capture_lex $P343
-    $P343($P341)
-  loop349_next:
-    goto loop349_test
-  loop349_handler:
+.sub "unary"  :subid("35") :method :outer("38")
+    .param pmc param_353
+    .param pmc param_354
+    new $P352, 'ExceptionHandler'
+    set_addr $P352, control_351
+    $P352."handle_types"(58)
+    push_eh $P352
+    .lex "$/", param_353
+    .lex "$key", param_354
+    get_hll_global $P355, ["PAST"], "Op"
+    find_lex $P356, "$key"
+    unless_null $P356, vivify_116
+    new $P356, "Undef"
+  vivify_116:
+    find_lex $P357, "$/"
+    unless_null $P357, vivify_117
+    new $P357, "Undef"
+  vivify_117:
+    $P358 = $P355."new"($P356 :named("name"), "call" :named("pasttype"), $P357 :named("node"))
+    .lex "$res", $P358
+    find_lex $P359, "$res"
+    unless_null $P359, vivify_118
+    new $P359, "Undef"
+  vivify_118:
+    find_lex $P360, "$/"
+    set $P361, $P360["value"]
+    unless_null $P361, vivify_119
+    new $P361, "Undef"
+  vivify_119:
+    $P362 = $P361."item"()
+    $P359."push"($P362)
+    find_lex $P363, "$/"
+    find_lex $P364, "$res"
+    unless_null $P364, vivify_120
+    new $P364, "Undef"
+  vivify_120:
+    $P365 = $P363."result_object"($P364)
+    .return ($P365)
+  control_351:
     .local pmc exception 
     .get_results (exception) 
-    getattribute $P351, exception, 'type'
-    eq $P351, 64, loop349_next
-    eq $P351, 66, loop349_redo
-  loop349_done:
-    pop_eh 
-  for_undef_116:
-    find_lex $P352, "$/"
-    find_lex $P353, "$res"
-    unless_null $P353, vivify_119
-    new $P353, "Undef"
-  vivify_119:
-    $P354 = $P352."result_object"($P353)
-    .return ($P354)
-  control_329:
-    .local pmc exception 
-    .get_results (exception) 
-    getattribute $P355, exception, "payload"
-    .return ($P355)
+    getattribute $P366, exception, "payload"
+    .return ($P366)
     rethrow exception
 .end
 
 
 .namespace ["z2";"Grammar";"Actions"]
-.sub "_block342"  :anon :subid("33") :outer("32")
-    .param pmc param_344
-    .lex "$_", param_344
-    find_lex $P345, "$res"
-    unless_null $P345, vivify_117
-    new $P345, "Undef"
-  vivify_117:
-    find_lex $P346, "$_"
-    unless_null $P346, vivify_118
-    new $P346, "Undef"
-  vivify_118:
-    $P347 = $P346."item"()
-    $P348 = $P345."push"($P347)
-    .return ($P348)
+.sub "binary"  :subid("36") :method :outer("38")
+    .param pmc param_370
+    .param pmc param_371
+    new $P369, 'ExceptionHandler'
+    set_addr $P369, control_368
+    $P369."handle_types"(58)
+    push_eh $P369
+    .lex "$/", param_370
+    .lex "$key", param_371
+    get_hll_global $P372, ["PAST"], "Op"
+    find_lex $P373, "$key"
+    unless_null $P373, vivify_121
+    new $P373, "Undef"
+  vivify_121:
+    find_lex $P374, "$/"
+    unless_null $P374, vivify_122
+    new $P374, "Undef"
+  vivify_122:
+    $P375 = $P372."new"($P373 :named("name"), "call" :named("pasttype"), $P374 :named("node"))
+    .lex "$res", $P375
+    find_lex $P377, "$/"
+    set $P378, $P377["value"]
+    unless_null $P378, vivify_123
+    new $P378, "Undef"
+  vivify_123:
+    defined $I379, $P378
+    unless $I379, for_undef_124
+    iter $P376, $P378
+    new $P389, 'ExceptionHandler'
+    set_addr $P389, loop388_handler
+    $P389."handle_types"(64, 66, 65)
+    push_eh $P389
+  loop388_test:
+    unless $P376, loop388_done
+    shift $P380, $P376
+  loop388_redo:
+    .const 'Sub' $P382 = "37" 
+    capture_lex $P382
+    $P382($P380)
+  loop388_next:
+    goto loop388_test
+  loop388_handler:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P390, exception, 'type'
+    eq $P390, 64, loop388_next
+    eq $P390, 66, loop388_redo
+  loop388_done:
+    pop_eh 
+  for_undef_124:
+    find_lex $P391, "$/"
+    find_lex $P392, "$res"
+    unless_null $P392, vivify_127
+    new $P392, "Undef"
+  vivify_127:
+    $P393 = $P391."result_object"($P392)
+    .return ($P393)
+  control_368:
+    .local pmc exception 
+    .get_results (exception) 
+    getattribute $P394, exception, "payload"
+    .return ($P394)
+    rethrow exception
 .end
 
+
+.namespace ["z2";"Grammar";"Actions"]
+.sub "_block381"  :anon :subid("37") :outer("36")
+    .param pmc param_383
+    .lex "$_", param_383
+    find_lex $P384, "$res"
+    unless_null $P384, vivify_125
+    new $P384, "Undef"
+  vivify_125:
+    find_lex $P385, "$_"
+    unless_null $P385, vivify_126
+    new $P385, "Undef"
+  vivify_126:
+    $P386 = $P385."item"()
+    $P387 = $P384."push"($P386)
+    .return ($P387)
+.end
+

File src/gen_grammar.pir

       .sub '__onload' :load :init
           .local pmc optable
           ## namespace z2::Grammar
-          push_eh onload_1407
+          push_eh onload_1421
           .local pmc p6meta
           p6meta = get_hll_global 'P6metaclass'
           p6meta.'new_class'('z2::Grammar', 'parent'=>'PCT::Grammar')
-        onload_1407:
+        onload_1421:
           pop_eh
           .return ()
       .end
           if cutmark != 0 goto fail
           goto R672
 
-        R671: # subrule positive_noun
+        R671: # concat
+        R673: # subrule positive_noun
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'positive_noun'
-          if $I0 == 0 goto R671_1
+          if $I0 == 0 goto R673_1
           $P0 = find_method mob, 'positive_noun'
-          goto R671_2
-        R671_1:
+          goto R673_2
+        R673_1:
           $P0 = find_name 'positive_noun'
-          unless null $P0 goto R671_2
+          unless null $P0 goto R673_2
           say "Unable to find regex 'positive_noun'"
-        R671_2:
+        R673_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           captscope["positive_noun"] = captob
 
           pos = $P1
-          local_branch cstack, succeed
+          local_branch cstack, R674
           delete captscope["positive_noun"]
 
           goto fail
-        R672: # subrule negative_noun
+        R674: # action
+          $P1 = adverbs['action']
+          if null $P1 goto succeed
+          $I1 = can $P1, "noun"
+          if $I1 == 0 goto succeed
+          mpos = pos
+          $P1."noun"(mob, "one")
+          goto succeed
+        R672: # concat
+        R675: # subrule negative_noun
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'negative_noun'
-          if $I0 == 0 goto R672_1
+          if $I0 == 0 goto R675_1
           $P0 = find_method mob, 'negative_noun'
-          goto R672_2
-        R672_1:
+          goto R675_2
+        R675_1:
           $P0 = find_name 'negative_noun'
-          unless null $P0 goto R672_2
+          unless null $P0 goto R675_2
           say "Unable to find regex 'negative_noun'"
-        R672_2:
+        R675_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           captscope["negative_noun"] = captob
 
           pos = $P1
-          local_branch cstack, succeed
+          local_branch cstack, R676
           delete captscope["negative_noun"]
 
           goto fail
-        R670: # subrule neutral_noun
+        R676: # action
+          $P1 = adverbs['action']
+          if null $P1 goto succeed
+          $I1 = can $P1, "noun"
+          if $I1 == 0 goto succeed
+          mpos = pos
+          $P1."noun"(mob, "minus_one")
+          goto succeed
+        R670: # concat
+        R677: # subrule neutral_noun
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'neutral_noun'
-          if $I0 == 0 goto R670_1
+          if $I0 == 0 goto R677_1
           $P0 = find_method mob, 'neutral_noun'
-          goto R670_2
-        R670_1:
+          goto R677_2
+        R677_1:
           $P0 = find_name 'neutral_noun'
-          unless null $P0 goto R670_2
+          unless null $P0 goto R677_2
           say "Unable to find regex 'neutral_noun'"
-        R670_2:
+        R677_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           captscope["neutral_noun"] = captob
 
           pos = $P1
-          local_branch cstack, succeed
+          local_branch cstack, R678
           delete captscope["neutral_noun"]
 
           goto fail
-        R668: # subrule second_person_reflexive
+        R678: # action
+          $P1 = adverbs['action']
+          if null $P1 goto succeed
+          $I1 = can $P1, "noun"
+          if $I1 == 0 goto succeed
+          mpos = pos
+          $P1."noun"(mob, "one")
+          goto succeed
+        R668: # concat
+        R679: # subrule second_person_reflexive
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'second_person_reflexive'
-          if $I0 == 0 goto R668_1
+          if $I0 == 0 goto R679_1
           $P0 = find_method mob, 'second_person_reflexive'
-          goto R668_2
-        R668_1:
+          goto R679_2
+        R679_1:
           $P0 = find_name 'second_person_reflexive'
-          unless null $P0 goto R668_2
+          unless null $P0 goto R679_2
           say "Unable to find regex 'second_person_reflexive'"
-        R668_2:
+        R679_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           captscope["second_person_reflexive"] = captob
 
           pos = $P1
-          local_branch cstack, succeed
+          local_branch cstack, R680
           delete captscope["second_person_reflexive"]
 
           goto fail
-        R666: # subrule first_person
+        R680: # action
+          $P1 = adverbs['action']
+          if null $P1 goto succeed
+          $I1 = can $P1, "noun"
+          if $I1 == 0 goto succeed
+          mpos = pos
+          $P1."noun"(mob, "lookup")
+          goto succeed
+        R666: # concat
+        R681: # subrule first_person
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'first_person'
-          if $I0 == 0 goto R666_1
+          if $I0 == 0 goto R681_1
           $P0 = find_method mob, 'first_person'
-          goto R666_2
-        R666_1:
+          goto R681_2
+        R681_1:
           $P0 = find_name 'first_person'
-          unless null $P0 goto R666_2
+          unless null $P0 goto R681_2
           say "Unable to find regex 'first_person'"
-        R666_2:
+        R681_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           captscope["first_person"] = captob
 
           pos = $P1
-          local_branch cstack, succeed
+          local_branch cstack, R682
           delete captscope["first_person"]
 
           goto fail
-        R664: # subrule second_person
+        R682: # action
+          $P1 = adverbs['action']
+          if null $P1 goto succeed
+          $I1 = can $P1, "noun"
+          if $I1 == 0 goto succeed
+          mpos = pos
+          $P1."noun"(mob, "one")
+          goto succeed
+        R664: # concat
+        R683: # subrule second_person
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'second_person'
-          if $I0 == 0 goto R664_1
+          if $I0 == 0 goto R683_1
           $P0 = find_method mob, 'second_person'
-          goto R664_2
-        R664_1:
+          goto R683_2
+        R683_1:
           $P0 = find_name 'second_person'
-          unless null $P0 goto R664_2
+          unless null $P0 goto R683_2
           say "Unable to find regex 'second_person'"
-        R664_2:
+        R683_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           captscope["second_person"] = captob
 
           pos = $P1
-          local_branch cstack, succeed
+          local_branch cstack, R684
           delete captscope["second_person"]
 
           goto fail
-        R662: # subrule nothing
+        R684: # action
+          $P1 = adverbs['action']
+          if null $P1 goto succeed
+          $I1 = can $P1, "noun"
+          if $I1 == 0 goto succeed
+          mpos = pos
+          $P1."noun"(mob, "lookup")
+          goto succeed
+        R662: # concat
+        R685: # subrule nothing
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'nothing'
-          if $I0 == 0 goto R662_1
+          if $I0 == 0 goto R685_1
           $P0 = find_method mob, 'nothing'
-          goto R662_2
-        R662_1:
+          goto R685_2
+        R685_1:
           $P0 = find_name 'nothing'
-          unless null $P0 goto R662_2
+          unless null $P0 goto R685_2
           say "Unable to find regex 'nothing'"
-        R662_2:
+        R685_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           captscope["nothing"] = captob
 
           pos = $P1
-          local_branch cstack, succeed
+          local_branch cstack, R686
           delete captscope["nothing"]
 
           goto fail
+        R686: # action
+          $P1 = adverbs['action']
+          if null $P1 goto succeed
+          $I1 = can $P1, "noun"
+          if $I1 == 0 goto succeed
+          mpos = pos
+          $P1."noun"(mob, "one")
+          goto succeed
       .end
 
 ## <z2::Grammar::adjective>
         fail_match:
           cutmark = -3
           goto fail_cut
-        R:  # alt R673, R674
-          push ustack, pos
-          local_branch cstack, R673
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R674
-
-        R673:  # alt R675, R676
-          push ustack, pos
-          local_branch cstack, R675
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R676
-
-        R675:  # alt R677, R678
-          push ustack, pos
-          local_branch cstack, R677
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R678
-
-        R677:  # alt R679, R680
-          push ustack, pos
-          local_branch cstack, R679
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R680
-
-        R679: # subrule positive_adjective
+        R:  # alt R687, R688
+          push ustack, pos
+          local_branch cstack, R687
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R688
+
+        R687:  # alt R689, R690
+          push ustack, pos
+          local_branch cstack, R689
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R690
+
+        R689:  # alt R691, R692
+          push ustack, pos
+          local_branch cstack, R691
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R692
+
+        R691:  # alt R693, R694
+          push ustack, pos
+          local_branch cstack, R693
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R694
+
+        R693: # subrule positive_adjective
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'positive_adjective'
-          if $I0 == 0 goto R679_1
+          if $I0 == 0 goto R693_1
           $P0 = find_method mob, 'positive_adjective'
-          goto R679_2
-        R679_1:
+          goto R693_2
+        R693_1:
           $P0 = find_name 'positive_adjective'
-          unless null $P0 goto R679_2
+          unless null $P0 goto R693_2
           say "Unable to find regex 'positive_adjective'"
-        R679_2:
+        R693_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           delete captscope["positive_adjective"]
 
           goto fail
-        R680: # subrule neutral_adjective
+        R694: # subrule neutral_adjective
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'neutral_adjective'
-          if $I0 == 0 goto R680_1
+          if $I0 == 0 goto R694_1
           $P0 = find_method mob, 'neutral_adjective'
-          goto R680_2
-        R680_1:
+          goto R694_2
+        R694_1:
           $P0 = find_name 'neutral_adjective'
-          unless null $P0 goto R680_2
+          unless null $P0 goto R694_2
           say "Unable to find regex 'neutral_adjective'"
-        R680_2:
+        R694_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           delete captscope["neutral_adjective"]
 
           goto fail
-        R678: # subrule negative_adjective
+        R692: # subrule negative_adjective
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'negative_adjective'
-          if $I0 == 0 goto R678_1
+          if $I0 == 0 goto R692_1
           $P0 = find_method mob, 'negative_adjective'
-          goto R678_2
-        R678_1:
+          goto R692_2
+        R692_1:
           $P0 = find_name 'negative_adjective'
-          unless null $P0 goto R678_2
+          unless null $P0 goto R692_2
           say "Unable to find regex 'negative_adjective'"
-        R678_2:
+        R692_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           delete captscope["negative_adjective"]
 
           goto fail
-        R676: # subrule first_person_possessive
+        R690: # subrule first_person_possessive
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'first_person_possessive'
-          if $I0 == 0 goto R676_1
+          if $I0 == 0 goto R690_1
           $P0 = find_method mob, 'first_person_possessive'
-          goto R676_2
-        R676_1:
+          goto R690_2
+        R690_1:
           $P0 = find_name 'first_person_possessive'
-          unless null $P0 goto R676_2
+          unless null $P0 goto R690_2
           say "Unable to find regex 'first_person_possessive'"
-        R676_2:
+        R690_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           delete captscope["first_person_possessive"]
 
           goto fail
-        R674: # subrule second_person_possessive
+        R688: # subrule second_person_possessive
           captob = captscope
           $P0 = getattribute captob, '$.pos'
           $P0 = pos
           $I0 = can mob, 'second_person_possessive'
-          if $I0 == 0 goto R674_1
+          if $I0 == 0 goto R688_1
           $P0 = find_method mob, 'second_person_possessive'
-          goto R674_2
-        R674_1:
+          goto R688_2
+        R688_1:
           $P0 = find_name 'second_person_possessive'
-          unless null $P0 goto R674_2
+          unless null $P0 goto R688_2
           say "Unable to find regex 'second_person_possessive'"
-        R674_2:
+        R688_2:
           $P2 = adverbs['action']
           captob = $P0(captob, 'action'=>$P2)
           $P1 = getattribute captob, '$.pos'
           .return (mob)
         fail:
           local_return cstack
-        R:  # group 681
-          local_branch cstack, R682
-          if cutmark != 681 goto fail
+        R:  # group 695
+          local_branch cstack, R696
+          if cutmark != 695 goto fail
           cutmark = 0
           goto fail
 
-        R682: # concat
-        R683:  # alt R685, R686
-          push ustack, pos
-          local_branch cstack, R685
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R686
-
-        R685:  # alt R687, R688
-          push ustack, pos
-          local_branch cstack, R687
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R688
-
-        R687:  # alt R689, R690
-          push ustack, pos
-          local_branch cstack, R689
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R690
-
-        R689:  # alt R691, R692
-          push ustack, pos
-          local_branch cstack, R691
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R692
-
-        R691:  # alt R693, R694
-          push ustack, pos
-          local_branch cstack, R693
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R694
-
-        R693:  # alt R695, R696
-          push ustack, pos
-          local_branch cstack, R695
-          pos = pop ustack
-          if cutmark != 0 goto fail
-          goto R696
-
-        R695: # literal
+        R696: # concat
+        R697:  # alt R699, R700
+          push ustack, pos
+          local_branch cstack, R699
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R700
+
+        R699:  # alt R701, R702
+          push ustack, pos
+          local_branch cstack, R701
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R702
+
+        R701:  # alt R703, R704
+          push ustack, pos
+          local_branch cstack, R703
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R704
+
+        R703:  # alt R705, R706
+          push ustack, pos
+          local_branch cstack, R705
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R706
+
+        R705:  # alt R707, R708
+          push ustack, pos
+          local_branch cstack, R707
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R708
+
+        R707:  # alt R709, R710
+          push ustack, pos
+          local_branch cstack, R709
+          pos = pop ustack
+          if cutmark != 0 goto fail
+          goto R710
+
+        R709: # literal
           $I0 = pos + 3
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 3
           
           if $S0 != "iii" goto fail
           pos += 3
-          goto R684
-
-        R696: # literal
+          goto R698
+
+        R710: # literal
           $I0 = pos + 2
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 2
           
           if $S0 != "ii" goto fail
           pos += 2
-          goto R684
-
-        R694: # literal
+          goto R698
+
+        R708: # literal
           $I0 = pos + 2
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 2
           
           if $S0 != "iv" goto fail
           pos += 2
-          goto R684
-
-        R692: # literal
+          goto R698
+
+        R706: # literal
           $I0 = pos + 1
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 1
           
           if $S0 != "i" goto fail
           pos += 1
-          goto R684
-
-        R690: # literal
+          goto R698
+
+        R704: # literal
           $I0 = pos + 1
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 1
           
           if $S0 != "v" goto fail
           pos += 1
-          goto R684
-
-        R688: # literal
+          goto R698
+
+        R702: # literal
           $I0 = pos + 2
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 2
           
           if $S0 != "vi" goto fail
           pos += 2
-          goto R684
-
-        R686: # literal
+          goto R698
+
+        R700: # literal
           $I0 = pos + 3
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 3
           
           if $S0 != "vii" goto fail
           pos += 3
-          goto R684
-
-        R684: # cut 681
+          goto R698
+
+        R698: # cut 695
           local_branch cstack, succeed
-          cutmark = 681
+          cutmark = 695
           goto fail
 
       .end
           cutmark = -3
           goto fail_cut
         R: # concat
-        R698: # subrule ws
-          captob = captscope
-          $P0 = getattribute captob, '$.pos'
-          $P0 = pos
-          $I0 = can mob, 'ws'
-          if $I0 == 0 goto R698_1
-          $P0 = find_method mob, 'ws'
-          goto R698_2
-        R698_1:
-          $P0 = find_name 'ws'
-          unless null $P0 goto R698_2
-          say "Unable to find regex 'ws'"
-        R698_2:
-          $P2 = adverbs['action']
-          captob = $P0(captob, 'action'=>$P2)
-          $P1 = getattribute captob, '$.pos'
-          if $P1 <= -3 goto fail_match
-          if $P1 < 0 goto fail
-          
-          
-          pos = $P1
-          local_branch cstack, R699
-          
-          goto fail
-        R699: # literal
+        R712: # subrule ws
+          captob = captscope
+          $P0 = getattribute captob, '$.pos'
+          $P0 = pos
+          $I0 = can mob, 'ws'
+          if $I0 == 0 goto R712_1
+          $P0 = find_method mob, 'ws'
+          goto R712_2
+        R712_1:
+          $P0 = find_name 'ws'
+          unless null $P0 goto R712_2
+          say "Unable to find regex 'ws'"
+        R712_2:
+          $P2 = adverbs['action']
+          captob = $P0(captob, 'action'=>$P2)
+          $P1 = getattribute captob, '$.pos'
+          if $P1 <= -3 goto fail_match
+          if $P1 < 0 goto fail
+          
+          
+          pos = $P1
+          local_branch cstack, R713
+          
+          goto fail
+        R713: # literal
           $I0 = pos + 1
           if $I0 > lastpos goto fail
           $S0 = substr target, pos, 1
           
           if $S0 != "[" goto fail
           pos += 1
-          goto R700
-
-        R700: # subrule ws
-          captob = captscope
-          $P0 = getattribute captob, '$.pos'
-          $P0 = pos
-          $I0 = can mob, 'ws'
-          if $I0 == 0 goto R700_1
-          $P0 = find_method mob, 'ws'
-          goto R700_2
-        R700_1:
-          $P0 = find_name 'ws'
-          unless null $P0 goto R700_2
-          say "Unable to find regex 'ws'"
-        R700_2:
-          $P2 = adverbs['action']
-          captob = $P0(captob, 'action'=>$P2)
-          $P1 = getattribute captob, '$.pos'
-          if $P1 <= -3 goto fail_match
-          if $P1 < 0 goto fail
-          
-          
-          pos = $P1
-          local_branch cstack, R701
-          
-          goto fail